/LMAR=0/XLINE=3/FONT#0=BAXL30/FONT#1=BAXI30/FONT#2=BAXB30/FONT#3=BAXS30/FONT#4=METLB
␈↓ ↓N␈↓α␈↓ ←1


␈↓ ↓N␈↓∧␈↓ ∧ALISP - AN AMICUS CURIAE BRIEF
␈↓ ↓N␈↓∧␈↓ ε∪␈↓αV. R. Pratt
␈↓ ↓N␈↓α␈↓ ε31/10/77

␈↓ ↓N␈↓↓␈↓ β≡␈↓␈↓βU␈↓␈↓↓ To the complexity of building a single interface between people,
␈↓ ↓N␈↓↓␈↓ β≡machines, and problems, which has made this brief so long.



␈↓ ↓N␈↓This␈α
position␈α∞paper␈α
advances␈α∞reasons␈α
in␈α∞support␈α
of␈α∞the␈α
consideration␈α∞of␈α
LISP␈α∞as␈α
the␈α∞language␈α
of
␈↓ ↓N␈↓choice␈α
for␈α
use␈α
within␈α
the␈α
M.I.T.␈α
Electrical␈α
Engineering␈α
and␈α
Computer␈α
Science␈α∞Department.␈α
 There
␈↓ ↓N␈↓being␈α
no␈α
universally␈α∞agreed␈α
on␈α
dialect␈α∞of␈α
LISP␈α
to␈α∞date,␈α
I␈α
have␈α∞chosen␈α
to␈α
describe␈α∞MACLISP,␈α
the
␈↓ ↓N␈↓dialect␈αimplemented␈αat␈αMIT.␈α Even␈αwith␈αsuch␈αa␈αconcrete␈αobject␈αas␈αan␈αimplementation␈αthere␈αis␈αroom
␈↓ ↓N␈↓for␈α⊃interpretation␈α⊃of␈α⊃what␈α⊃has␈α⊃been␈α⊃implemented.␈α⊃ Thus␈α⊃it␈α⊃must␈α⊃be␈α⊃realized␈α⊃that␈α⊃the␈α⊂following
␈↓ ↓N␈↓represents one individual's perspective on one dialect of LISP.

␈↓ ↓N␈↓The␈α∞paper␈α∂is␈α∞divided␈α∂into␈α∞three␈α∂sections.␈α∞ The␈α∂␈↓βC␈↓rst␈α∞two␈α∂consider␈α∞LISP␈α∂␈↓↓in␈α∞vacuo␈↓,␈α∂without␈α∞detailed
␈↓ ↓N␈↓reference␈α
to␈α∞other␈α
languages␈α
and␈α∞without␈α
considering␈α
departmental␈α∞needs.␈α
 The␈α
third␈α∞section␈α
takes
␈↓ ↓N␈↓into account what we need a programming language for.
␈↓ ↓N␈↓αLISP Brief␈↓ b1


␈↓ ↓N␈↓A.  Merits of LISP.                         ␈↓ π∞␈↓In␈α⊂the␈α⊂MACLISP␈α⊂implementation␈α⊃the␈α⊂above
                                            ␈↓ π∞␈↓data␈α∪types␈α∪are␈α∩almost␈α∪"␈↓βC␈↓rst-class␈α∪citizens,"␈α∩a
␈↓ ↓N␈↓There␈α≤are␈α≤ten␈α≤sections␈α≤below,␈α≥with␈α≤␈↓βC␈↓rst           ␈↓ π∞␈↓term␈α
used␈α
by␈α∞the␈α
implementors␈α
of␈α∞POP-2␈α
[5]
␈↓ ↓N␈↓sentences as follows.                       ␈↓ π∞␈↓to␈αdescribe␈α
a␈αdata␈αtype␈α
that␈αcan␈α
be␈αpassed␈αas␈α
a
␈↓ ↓N␈↓␈↓ α∞1.  LISP is versatile.                      ␈↓ π∞␈↓parameter,␈α
returned␈α
by␈α
a␈α
function␈α
as␈α∞a␈α
value,
␈↓ ↓N␈↓␈↓ α∞2.  LISP is e␈↓β@␈↓icient.                       ␈↓ π∞␈↓assigned␈αto␈αa␈αvariable,␈αand␈αtested␈αfor␈αequality.
␈↓ ↓N␈↓␈↓ α∞3.  LISP uses a standard character set.     ␈↓ π∞␈↓LISP's␈α⊗data␈α⊗types␈α⊗include␈α⊗some␈α⊗for␈α∃which
␈↓ ↓N␈↓␈↓ α∞4.  LISP is interactive.                    ␈↓ π∞␈↓equality␈α∪cannot␈α∪be␈α∪decided,␈α∪namely␈α∪the␈α∩last
␈↓ ↓N␈↓␈↓ α∞5.  LISP is modular.                        ␈↓ π∞␈↓two.␈α If␈αwe␈α
rule␈αout␈αthe␈αlast␈α
requirement,␈αthen
␈↓ ↓N␈↓␈↓ α∞6.  LISP is notation-independent.           ␈↓ π∞␈↓all LISP data types are ␈↓βC␈↓rst-class citizens.
␈↓ ↓N␈↓␈↓ α∞7.  LISP is applicative.
␈↓ ↓N␈↓␈↓ α∞8.  LISP is widely used in academia.        ␈↓ π∞␈↓It␈α≤is␈α≤hard␈α≤to␈α≤appreciate␈α≥what␈α≤␈↓βC␈↓rst-class
␈↓ ↓N␈↓␈↓ α∞9.␈α~ LISP␈α~is␈α~used␈α~by␈α~half␈α~the␈α→MIT                   ␈↓ π∞␈↓citizenship␈α"really␈α#means␈α"until␈α#one␈α"has
␈↓ ↓N␈↓␈↓ αNComputer Science faculty.                   ␈↓ π∞␈↓programmed␈αwith␈αand␈αwithout␈αit.␈α Now␈αthat␈αI
␈↓ ↓N␈↓␈↓ α∞10.␈α∃ No␈α∃other␈α∃language␈α∃enjoys␈α∃all␈α∀the             ␈↓ π∞␈↓have␈α_adopted␈α_a␈α_programming␈α_style␈α↔which
␈↓ ↓N␈↓␈↓ αNabove advantages of LISP.                   ␈↓ π∞␈↓capitalizes␈α
on␈α
this␈α
asset␈α
of␈α
LISP,␈α
I␈α
␈↓βC␈↓nd␈α
that␈α
I
                                            ␈↓ π∞␈↓have␈α∞been␈α∞able␈α
to␈α∞clean␈α∞up␈α∞my␈α
programming
␈↓ ↓N␈↓1.␈α~ LISP␈α~is␈α→versatile.␈α~ Although␈α~LISP␈α→is          ␈↓ π∞␈↓style␈α∩to␈α⊃the␈α∩point␈α⊃where␈α∩I␈α⊃feel␈α∩I␈α∩am␈α⊃saying
␈↓ ↓N␈↓caricatured␈αby␈αnon-LISP␈α
users␈αas␈αbeing␈αof␈α
use      ␈↓ π∞␈↓things␈αthe␈αright␈αway.␈α This␈αis␈αno␈αmore␈α
than␈αa
␈↓ ↓N␈↓mainly␈α&for␈α%manipulation␈α&of␈α%irregularly          ␈↓ π∞␈↓generalization␈α→to␈α→other␈α→data␈α→types␈α~of␈α→the
␈↓ ↓N␈↓structured␈α~data,␈α≠this␈α~caricature␈α≠does␈α~little     ␈↓ π∞␈↓experience␈α(of␈α)a␈α(generation␈α)of␈α(LISP
␈↓ ↓N␈↓justice␈αto␈αthe␈αcareful␈αwork␈αdone␈αby␈αMcCarthy,      ␈↓ π∞␈↓programmers␈α∩in␈α∩writing␈α∩programs␈α∩that␈α∩treat
␈↓ ↓N␈↓Levin␈α∩and␈α⊃others␈α∩in␈α⊃the␈α∩formative␈α∩years␈α⊃of         ␈↓ π∞␈↓numbers␈α∨and␈α lists␈α∨as␈α ␈↓βC␈↓rst-class␈α∨citizens.
␈↓ ↓N␈↓LISP␈α%(around␈α&1960)␈α%in␈α&developing␈α%a               ␈↓ π∞␈↓MACLISP␈α,has␈α+merely␈α,extended␈α+this
␈↓ ↓N␈↓mathematically␈αclean␈αyet␈αgeneral␈αprogramming    ␈↓ π∞␈↓convenience␈α
to␈αits␈α
other␈α
data␈αtypes.␈α
For␈α
me␈αto
␈↓ ↓N␈↓language.␈α! Certainly␈α"Arti␈↓βC␈↓cial␈α!Intelligence    ␈↓ π∞␈↓return␈α∪to␈α∪the␈α∩situation␈α∪that␈α∪obtains␈α∪in,␈α∩say,
␈↓ ↓N␈↓applications␈α≥were␈α≥a␈α≥concern␈α≥during␈α≤that          ␈↓ π∞␈↓ALGOL␈α≥or␈α≤PASCAL,␈α≥where␈α≥an␈α≤array-
␈↓ ↓N␈↓development;␈α∀after␈α∪all,␈α∀AI␈α∪was␈α∀the␈α∪nutrient       ␈↓ π∞␈↓producing␈αsubroutine␈αmust␈αbe␈αgiven␈αthe␈αarray
␈↓ ↓N␈↓medium␈α⊃within␈α⊃which␈α⊃LISP␈α⊃developed.␈α⊃ Yet         ␈↓ π∞␈↓as␈α∩input,␈α∩would␈α∩force␈α∩me␈α∩back␈α∩to␈α∩a␈α∩clumsy
␈↓ ↓N␈↓the␈α$language␈α$has␈α$managed␈α$to␈α#remain               ␈↓ π∞␈↓style␈α∀that␈α∪I␈α∀now␈α∪know␈α∀is␈α∀unnecessary.␈α∪The
␈↓ ↓N␈↓remarkably␈α∞free␈α∞of␈α∞the␈α∞concessions␈α∞one␈α∞might      ␈↓ π∞␈↓same␈α∂remark␈α∂applies␈α∂to␈α∂the␈α∂other␈α⊂data␈α∂types;
␈↓ ↓N␈↓expect␈α
to␈α
arise␈α
from␈α
such␈α
pressures,␈α
and␈α∞is␈α
in      ␈↓ π∞␈↓for␈α∂example␈α∂the␈α⊂ability␈α∂to␈α∂pass␈α⊂property␈α∂lists
␈↓ ↓N␈↓our␈αview␈αone␈α
of␈αthe␈αmost␈α
domain-independent       ␈↓ π∞␈↓around␈α without␈α requiring␈α that␈α!they␈α be
␈↓ ↓N␈↓languages currently enjoying wide usage.    ␈↓ π∞␈↓attached␈αto␈αa␈αparticular␈αatom␈αmade␈αit␈αpossible
                                            ␈↓ π∞␈↓for␈α me␈α to␈α implement␈α!the␈α Boyer-Moore
␈↓ ↓N␈↓We␈α may␈α∨illustrate␈α LISP's␈α versatility␈α∨by          ␈↓ π∞␈↓uni␈↓βC␈↓cation␈α∩algorithm␈α∩in␈α∩a␈α∩cleaner␈α∩way␈α∩than
␈↓ ↓N␈↓reference to its data types.  These are:    ␈↓ π∞␈↓Boyer and Moore implemented it.
␈↓ ↓N␈↓␈↓ ↓n␈↓↓numbers␈↓ integers (unlimited size), reals
␈↓ ↓N␈↓␈↓ ↓n␈↓↓bit␈α*vectors␈↓␈α)various␈α*applications,␈α)e.g.          ␈↓ π∞␈↓For␈α∪some,␈α∪the␈α∪data␈α∪types␈α∪FUNCTION␈α∩and
␈↓ ↓N␈↓␈↓ αNPASCAL's sets                               ␈↓ π∞␈↓PROGRAM␈α∞truly␈α∞set␈α∞LISP␈α∞apart␈α∞from␈α
other
␈↓ ↓N␈↓␈↓ ↓n␈↓↓booleans␈↓ T and NIL (for false)              ␈↓ π∞␈↓languages.␈α
 To␈αbe␈α
precise,␈αthis␈α
power␈αdepends
␈↓ ↓N␈↓␈↓ ↓n␈↓↓atoms␈↓␈α∩serving␈α∩double␈α∩duty␈α∩as␈α∩strings␈α∩and          ␈↓ π∞␈↓on␈α_objects␈α_of␈α_these␈α_types␈α→being␈α_␈↓βC␈↓rst-class
␈↓ ↓N␈↓␈↓ αNvariables                                   ␈↓ π∞␈↓citizens␈α≤in␈α≤the␈α≤POP-2␈α≤sense.␈α≤ This␈α≤has
␈↓ ↓N␈↓␈↓ ↓n␈↓↓lists␈↓ for which LISP is best known          ␈↓ π∞␈↓certainly␈αbeen␈αthe␈αcase␈αfor␈αme.␈α For␈α
a␈αnumber
␈↓ ↓N␈↓␈↓ ↓n␈↓↓property␈α≡lists␈↓␈α≡various␈α∨applications,␈α≡e.g.       ␈↓ π∞␈↓of␈α3years,␈α4starting␈α3with␈α4the␈α31970
␈↓ ↓N␈↓␈↓ αNPASCAL's records                            ␈↓ π∞␈↓implementations␈α≥of␈α≥my␈α≥LINGOL␈α≥natural
␈↓ ↓N␈↓␈↓ ↓n␈↓↓arrays␈↓ unrestricted as to type or dimension ␈↓ π∞␈↓language␈α→system␈α→and␈α→my␈α→CGOL␈α_syntactic
␈↓ ↓N␈↓␈↓ ↓n␈↓↓function(al)s␈↓ using LAMBDA and APPLY        ␈↓ π∞␈↓front-end␈α
for␈α
LISP,␈α
I␈αhave␈α
built␈α
much␈α
of␈αmy
␈↓ ↓N␈↓␈↓ ↓n␈↓↓programs␈↓ using EVAL and QUOTE               ␈↓ π∞␈↓software␈α⊂around␈α⊂a␈α∂central␈α⊂philosophy␈α⊂that␈α∂is
␈↓ ↓N␈↓αLISP Brief␈↓ `2


␈↓ ↓N␈↓best␈α↔described␈α⊗as␈α↔ACTOR-oriented␈α↔[2].␈α⊗ I         ␈↓ π∞␈↓experiment␈α∂cited␈α∞above,␈α∂the␈α∂slight␈α∞superiority
␈↓ ↓N␈↓store␈α
information␈αin␈α
small␈αmodules␈α
that␈αcan␈α
be     ␈↓ π∞␈↓of␈α⊂the␈α⊂LISP␈α⊂code␈α⊂(involving␈α⊃an␈α⊂insigni␈↓βC␈↓cant
␈↓ ↓N␈↓evaluated␈α∃by␈α∃LISP␈α∃when␈α∃they␈α∃need␈α⊗to␈α∃be             ␈↓ π∞␈↓factor␈α⊂of␈α∂about␈α⊂1.2)␈α∂was␈α⊂traceable␈α∂not␈α⊂to␈α∂the
␈↓ ↓N␈↓queried.␈α∂ The␈α⊂advantage␈α∂of␈α⊂this␈α∂style␈α⊂is␈α∂that      ␈↓ π∞␈↓code␈α
generated␈α
for␈αthe␈α
arithmetic␈α
parts␈α
of␈αthe
␈↓ ↓N␈↓such␈α≡information␈α≥can␈α≡be␈α≡made␈α≥context-            ␈↓ π∞␈↓program,␈α∂which␈α⊂was␈α∂almost␈α∂identical␈α⊂in␈α∂each
␈↓ ↓N␈↓dependent␈α⊂because␈α⊂like␈α⊂all␈α⊂LISP␈α⊂code␈α⊃it␈α⊂has        ␈↓ π∞␈↓case,␈α
but␈αrather␈α
to␈αthe␈α
more␈αe␈↓β@␈↓icient␈α
procedure
␈↓ ↓N␈↓access␈α≡to␈α≡the␈α≡environment.␈α≡ Moreover␈α≡a           ␈↓ π∞␈↓calling␈α↔in␈α⊗LISP.␈α↔ This␈α⊗I␈α↔feel␈α⊗convincingly
␈↓ ↓N␈↓module␈α↔can␈α↔be␈α↔"intelligent"␈α↔about␈α↔what␈α⊗it         ␈↓ π∞␈↓disposes␈α∃of␈α∃the␈α∃argument␈α⊗that␈α∃FORTRAN
␈↓ ↓N␈↓answers,␈αpossibly␈α
calling␈αon␈αother␈α
modules␈αfor    ␈↓ π∞␈↓(and␈α∞hence␈α∞presumably␈α∞most␈α∞other␈α∞high␈α∞level
␈↓ ↓N␈↓help␈α~before␈α≠making␈α~up␈α~its␈α≠mind.␈α~ Good             ␈↓ π∞␈↓languages)␈α
is␈αmore␈α
appropriate␈αwhen␈α
e␈↓β@␈↓iciency
␈↓ ↓N␈↓examples␈α
of␈α∞how␈α
powerful␈α
this␈α∞technique␈α
can       ␈↓ π∞␈↓is needed.
␈↓ ↓N␈↓be␈α∞in␈α
practical␈α∞situations␈α∞can␈α
be␈α∞found␈α∞in␈α
[7]
␈↓ ↓N␈↓and␈α_[8].␈α→ Carl␈α_Hewitt␈α→has␈α_built␈α→a␈α_whole            ␈↓ π∞␈↓Professor␈α~Bers␈α~group,␈α~which␈α~although␈α→in
␈↓ ↓N␈↓programming␈α∪language␈α∀based␈α∪solely␈α∀on␈α∪this        ␈↓ π∞␈↓EECS␈α∞is␈α∞not␈α∞a␈α∞part␈α∞of␈α∞the␈α∞Computer␈α∞Science
␈↓ ↓N␈↓philosophy␈α(which␈αarose␈αin␈αhis␈αcase␈αout␈αof␈αhis      ␈↓ π∞␈↓laboratories␈α∂(LCS␈α∂and␈α∂AI),␈α∂does␈α∂considerable
␈↓ ↓N␈↓earlier␈α#work␈α#on␈α#PLANNER)␈α#and␈α"has                 ␈↓ π∞␈↓"number␈α≤crunching,"␈α≤having␈α≥used␈α≤several
␈↓ ↓N␈↓demonstrated␈α+how␈α+ACTORS␈α,can␈α+by                  ␈↓ π∞␈↓hundred␈αhours␈αof␈αcomputer␈αtime␈αfor␈αa␈αvariety
␈↓ ↓N␈↓themselves␈α
supply␈α
the␈α
only␈α
foundations␈α
needed    ␈↓ π∞␈↓of␈αheavily␈αnumerical␈αproblems.␈α John␈αL.␈αKulp
␈↓ ↓N␈↓for␈α→a␈α→versatile␈α→and␈α→e␈↓β@␈↓icient␈α_programming         ␈↓ π∞␈↓of␈α⊃that␈α⊃group␈α⊃has␈α⊃experimented␈α⊃with␈α∩a␈α⊃few
␈↓ ↓N␈↓language,␈α_using␈α_methods␈α_analogous␈α_to␈α↔the         ␈↓ π∞␈↓numerical␈α~problems␈α~using␈α~FORTRAN␈α~on
␈↓ ↓N␈↓corresponding␈α≠demonstration␈α~for␈α≠the␈α~pure        ␈↓ π∞␈↓MULTICS␈αand␈αthe␈α370/168,␈αand␈αLISP␈α
(under
␈↓ ↓N␈↓lambda-calculus.                            ␈↓ π∞␈↓MACSYMA)␈α⊗on␈α⊗a␈α⊗PDP10␈α⊗with␈α⊗a␈α∃KL-10
                                            ␈↓ π∞␈↓processor.␈α∪ Although␈α∪the␈α∪arithmetic␈α∀unit␈α∪on
                                            ␈↓ π∞␈↓the␈α⊃168␈α⊃has␈α⊃twice␈α∩the␈α⊃speed␈α⊃of␈α⊃that␈α∩on␈α⊃the
␈↓ ↓N␈↓2.␈α⊃ LISP␈α⊂is␈α⊃e␈↓β@␈↓icient.␈α⊂ Another␈α⊃myth␈α⊂popular       ␈↓ π∞␈↓KL-10,␈α∞that␈α∂group␈α∞has␈α∞chosen␈α∂to␈α∞do␈α∂most␈α∞of
␈↓ ↓N␈↓among␈α∩non-LISP␈α⊃users␈α∩is␈α⊃that␈α∩to␈α∩use␈α⊃LISP           ␈↓ π∞␈↓their␈α8work␈α7on␈α8the␈α8PDP-10␈α7in
␈↓ ↓N␈↓one␈α⊃resigns␈α⊃oneself␈α⊃to␈α⊃gross␈α⊃ine␈↓β@␈↓iciency.␈α⊃ To     ␈↓ π∞␈↓LISP/MACSYMA,␈α∪both␈α∪because␈α∪that␈α∩factor
␈↓ ↓N␈↓put␈αthis␈αshibboleth␈αto␈αthe␈αtest,␈αmembers␈αof␈αthe     ␈↓ π∞␈↓of␈α!two␈α!is␈α considerably␈α!diluted␈α!by␈α the
␈↓ ↓N␈↓MACSYMA␈α≠project␈α≠took␈α≠some␈α~numerical             ␈↓ π∞␈↓associated␈α.and␈α.inevitable␈α.non-numeric
␈↓ ↓N␈↓benchmark␈α⊗programs␈α↔of␈α⊗the␈α⊗sort␈α↔that␈α⊗one           ␈↓ π∞␈↓processing␈α⊂and␈α∂because␈α⊂of␈α∂the␈α⊂advantages␈α∂of
␈↓ ↓N␈↓would␈α∞normally␈α∞think␈α∞of␈α∞as␈α∂being␈α∞well-suited      ␈↓ π∞␈↓LISP␈α∂over␈α⊂FORTRAN.␈α∂ (It␈α∂should␈α⊂be␈α∂noted
␈↓ ↓N␈↓to␈α_FORTRAN␈α_compilation,␈α_and␈α↔compared            ␈↓ π∞␈↓that␈α⊂MACSYMA␈α∂uses␈α⊂an␈α⊂algebraic␈α∂notation,
␈↓ ↓N␈↓their␈α∨running␈α∨times␈α∨under␈α∨each␈α∨of␈α≡an              ␈↓ π∞␈↓removing␈α;any␈α<notational␈α;advantage
␈↓ ↓N␈↓(admittedly␈αold)␈αFORTRAN␈αcompiler␈αand␈αthe        ␈↓ π∞␈↓FORTRAN␈α∪may␈α∀possess␈α∪over␈α∀the␈α∪standard
␈↓ ↓N␈↓LISP␈αcompiler␈αused␈αat␈αMIT␈αon␈αITS␈α[1].␈α
 Both         ␈↓ π∞␈↓LISP notation.)
␈↓ ↓N␈↓compilations␈α_were␈α_performed␈α_on␈α_the␈α↔same
␈↓ ↓N␈↓machine,␈αa␈αPDP-10.␈α The␈αLISP␈αcompiler␈α
won!        ␈↓ π∞␈↓This␈αis␈αnot␈αto␈αsay␈αthat␈αone␈αcannot␈α
write␈αLISP
␈↓ ↓N␈↓With␈αa␈αlittle␈αthought␈αit␈αbecomes␈αapparent␈αthat     ␈↓ π∞␈↓programs␈α
that␈α
are␈α
ine␈↓β@␈↓icient.␈α
 In␈α
a␈α
language␈α
as
␈↓ ↓N␈↓ine␈↓β@␈↓icient␈α∩object␈α∩code␈α∪does␈α∩not␈α∩inhere␈α∪in␈α∩a        ␈↓ π∞␈↓versatile␈αas␈αLISP␈α
it␈αis␈αinevitable␈αthat␈α
the␈αuser
␈↓ ↓N␈↓language␈α
but␈αrather␈α
is␈α
the␈αresult␈α
either␈α
of␈αthe     ␈↓ π∞␈↓will␈α
want␈αto␈α
take␈αadvantage␈α
of␈α
constructs␈αthat
␈↓ ↓N␈↓program␈α⊃demanding␈α⊂something␈α⊃di␈↓β@␈↓icult␈α⊂such       ␈↓ π∞␈↓linguistically␈α~express␈α~perfectly␈α~what␈α~he␈α~is
␈↓ ↓N␈↓as␈αa␈αcomplicated␈αparameter-passing␈αtask,␈αor␈αof    ␈↓ π∞␈↓trying␈α~to␈α~say␈α~but␈α~computationally␈α→present
␈↓ ↓N␈↓the␈α∀compiler-writers␈α∪not␈α∀doing␈α∪a␈α∀good␈α∪job.        ␈↓ π∞␈↓obstacles␈α⊗to␈α⊗e␈↓β@␈↓icient␈α⊗code␈α⊗generation.␈α⊗ Our
␈↓ ↓N␈↓After␈α!all,␈α!why␈α!should␈α!the␈α FORTRAN                ␈↓ π∞␈↓position␈α∞on␈α∞this␈α∞is␈α
that␈α∞the␈α∞default␈α∞should␈α
be
␈↓ ↓N␈↓statement                                   ␈↓ π∞␈↓that␈α∃the␈α∃programmer␈α∃feel␈α⊗no␈α∃compunctions
␈↓ ↓N␈↓   A(I,J) = B(I,K)*C(K,J)                   ␈↓ π∞␈↓about␈α⊗using␈α⊗to␈α⊗the␈α⊗full␈α⊗the␈α⊗features␈α⊗of␈α⊗a
␈↓ ↓N␈↓and the LISP statement                      ␈↓ π∞␈↓language,␈α
but␈α
that␈α
on␈α
those␈α
occasions␈α
when␈α
it
␈↓ ↓N␈↓   (STORE (A I J) (TIMES (B I K) (C K J)))  ␈↓ π∞␈↓truly␈α∩is␈α∩the␈α∪case␈α∩that␈α∩the␈α∩machine's␈α∪time␈α∩is
␈↓ ↓N␈↓produce␈α∞di␈↓β@␈↓erent␈α
object␈α∞code?␈α
 In␈α∞fact,␈α∞in␈α
the     ␈↓ π∞␈↓worth␈α⊂more␈α⊂than␈α⊂the␈α⊃programmer's␈α⊂(together
␈↓ ↓N␈↓αLISP Brief␈↓ `3


␈↓ ↓N␈↓with␈α∞the␈α∞time␈α∞of␈α∂those␈α∞who␈α∞have␈α∞to␈α∂read␈α∞his          ␈↓ π∞␈↓further␈α⊃ado.␈α⊃ If␈α⊃one␈α⊃wants␈α⊃to␈α⊃get␈α⊃a␈α⊃big␈α⊃job
␈↓ ↓N␈↓code)␈α~then␈α~the␈α~programmer␈α≠should␈α~know            ␈↓ π∞␈↓underway,␈α∪one␈α∪simply␈α∪invokes␈α∀the␈α∪top-level
␈↓ ↓N␈↓which␈α∀constructions␈α∀to␈α∀avoid␈α∀to␈α∀permit␈α∪the        ␈↓ π∞␈↓function␈α∞of␈α
that␈α∞job␈α
in␈α∞exactly␈α
the␈α∞same␈α
way.
␈↓ ↓N␈↓optimizer␈αto␈αdo␈α
as␈αgood␈αa␈α
job␈αwith␈αhis␈αcode␈α
as        ␈↓ π∞␈↓And␈α
of␈α
course␈α
one's␈α
program␈α
can␈α
always␈α
type
␈↓ ↓N␈↓a␈αgood␈αFORTRAN␈α
optimizer␈αcan␈αdo.␈α Thus␈α
a           ␈↓ π∞␈↓directly␈αto␈αthe␈αuser␈αand␈αaccept␈αinput␈αfrom␈αhim
␈↓ ↓N␈↓systems␈α∨programmer␈α∨writing␈α∨widely␈α∨used          ␈↓ π∞␈↓at␈α⊂any␈α⊂time.␈α⊂ Perhaps␈α⊂more␈α⊂signi␈↓βC␈↓cantly,␈α∂one
␈↓ ↓N␈↓systems␈α
code␈α
in␈α
LISP␈α
might␈α
as␈α
a␈α
general␈α
policy      ␈↓ π∞␈↓can␈α∪interact␈α∪with␈α∪one's␈α∪program␈α∪while␈α∪it␈α∩is
␈↓ ↓N␈↓avoid␈α heavy␈α use␈α∨of␈α functions␈α that␈α∨do              ␈↓ π∞␈↓running,␈α⊃interrupting␈α⊂to␈α⊃both␈α⊃modify␈α⊂and/or
␈↓ ↓N␈↓considerable␈αwork␈αto␈αkeep␈αthe␈α
environment␈αin      ␈↓ π∞␈↓examine␈α#the␈α#environment.␈α# In␈α"powerful
␈↓ ↓N␈↓a␈α
consistent␈αstate␈α
such␈αas␈α
code␈α
associated␈αwith    ␈↓ π∞␈↓languages␈α?␈αβlike␈α?␈α∧LISP,␈α?␈αβenvironment
␈↓ ↓N␈↓LISP's␈α"special"␈αvariables.␈α (If␈αone␈αdoubts␈αthat  ␈↓ π∞␈↓examination␈αis␈αmade␈αmore␈αcomplicated␈α
by␈αthe
␈↓ ↓N␈↓e␈↓β@␈↓icient␈α
systems␈α
programming␈α
can␈α
be␈α
done␈α
in       ␈↓ π∞␈↓complexity␈α∀of␈α∀the␈α∀environment;␈α∀nevertheless
␈↓ ↓N␈↓LISP,␈αI␈α
should␈αpoint␈α
to␈αthe␈α
CGOL␈αsubsystem         ␈↓ π∞␈↓LISP␈α∀provides␈α∃the␈α∀tools␈α∀needed␈α∃to␈α∀explore
␈↓ ↓N␈↓of␈α
LISP␈α
that␈α
I␈α
have␈α
developed␈α
to␈α
provide␈αan         ␈↓ π∞␈↓nested contexts and complex data structures.
␈↓ ↓N␈↓algebraic␈α"notation␈α"for␈α"MACLISP␈α!users,
␈↓ ↓N␈↓discussed␈αin␈αmore␈αdetail␈αin␈αsection␈α6.␈α Users␈αof
␈↓ ↓N␈↓this␈α
dialect␈α
sacri␈↓βC␈↓ce␈α
approximately␈α
a␈α∞factor␈α
of   ␈↓ π∞␈↓5.␈α∃ LISP␈α∃is␈α∃modular.␈α∀ One␈α∃of␈α∃the␈α∃joys␈α∀of
␈↓ ↓N␈↓two␈α⊂in␈α⊂speed␈α∂in␈α⊂reading␈α⊂their␈α⊂programs␈α∂into        ␈↓ π∞␈↓programming␈α%in␈α%LISP␈α%is␈α&that␈α%almost
␈↓ ↓N␈↓LISP␈α∞when␈α∂they␈α∞are␈α∞running␈α∂those␈α∞programs         ␈↓ π∞␈↓everything␈α/one␈α/does␈α/can␈α/be␈α.done
␈↓ ↓N␈↓interpretively,␈α∂and␈α∂a␈α∂negligible␈α⊂amount␈α∂when     ␈↓ π∞␈↓incrementally,␈αeither␈αon␈α
the␈αuser's␈αcommand␈α
or
␈↓ ↓N␈↓they␈α⊂are␈α⊂compiling␈α⊂their␈α⊂programs.␈α⊂ Some␈α∂of       ␈↓ π∞␈↓under␈α∞program␈α∞control␈α∞in␈α∞all␈α∞cases.␈α∞ If␈α∞one␈α∞is
␈↓ ↓N␈↓this␈α#can␈α"be␈α#attributed␈α"to␈α#the␈α"greater             ␈↓ π∞␈↓running␈α≤a␈α≠LISP␈α≤program␈α≠and␈α≤wants␈α≠to
␈↓ ↓N␈↓complexity␈αof␈αparsing␈αan␈αalgebraic␈αas␈αopposed     ␈↓ π∞␈↓interrupt␈αit␈αto␈α
write␈αanother␈αfunction,␈α
one␈αcan
␈↓ ↓N␈↓to␈α⊃a␈α⊂fully␈α⊃parenthesized␈α⊂pre␈↓βC␈↓x␈α⊃notation,␈α⊂and      ␈↓ π∞␈↓do␈α∂so␈α∞on␈α∂the␈α∂spot␈α∞without␈α∂having␈α∂to␈α∞re-read
␈↓ ↓N␈↓the␈αremainder␈αto␈αthe␈αfact␈αthat␈αthe␈αsubsystem␈α
is     ␈↓ π∞␈↓the␈α⊃whole␈α∩program␈α⊃back␈α∩into␈α⊃LISP.␈α∩ If␈α⊃one
␈↓ ↓N␈↓written␈αin␈αLISP␈αinstead␈αof␈α
assembly␈αlanguage.     ␈↓ π∞␈↓takes␈α∂a␈α∂dislike␈α∂to␈α∞the␈α∂behavior␈α∂of␈α∂the␈α∞lexical
␈↓ ↓N␈↓I␈α∞believe␈α∞a␈α
substantial␈α∞proportion␈α∞of␈α∞this␈α
gap     ␈↓ π∞␈↓analyzer,␈α
its␈α∞behavior␈α
can␈α∞be␈α
modi␈↓βC␈↓ed␈α∞on␈α
the
␈↓ ↓N␈↓can␈α⊂be␈α⊂eliminated␈α⊂by␈α⊂writing␈α⊂the␈α⊂LISP␈α⊂code         ␈↓ π∞␈↓spot,␈α≤either␈α≤locally␈α≤or␈α≤by␈α≤wholesale␈α≠and
␈↓ ↓N␈↓with␈α∂more␈α∂attention␈α∂to␈α∂speed;␈α∂at␈α∂present␈α∂it␈α∞is      ␈↓ π∞␈↓instantaneous␈α'replacement␈α'with␈α(a␈α'new
␈↓ ↓N␈↓written␈α
with␈αconcern␈α
only␈αfor␈α
legibility␈αand␈α
my    ␈↓ π∞␈↓analyzer.␈α
 If␈αthe␈α
routine␈αused␈α
by␈α
the␈αtop-level
␈↓ ↓N␈↓programming␈α⊗time,␈α⊗with␈α⊗heavy␈α⊗use␈α⊗of␈α∃the           ␈↓ π∞␈↓listen␈α
loop␈α
to␈αprint␈α
the␈α
answer␈αis␈α
inappropriate
␈↓ ↓N␈↓fore-mentioned␈α∞"special"␈α
variables␈α∞and␈α
"over-   ␈↓ π∞␈↓to␈α≠the␈α≠task,␈α≠it␈α≠can␈α≠be␈α≠changed␈α≤in␈α≠one
␈↓ ↓N␈↓modularization"␈αof␈αthe␈αcode␈αresulting␈αin␈αmany     ␈↓ π∞␈↓command;␈α∩in␈α⊃fact,␈α∩the␈α⊃entire␈α∩top-level␈α⊃listen
␈↓ ↓N␈↓more procedure calls than really necessary.)␈↓ π∞␈↓loop␈α⊗can␈α⊗be␈α∃replaced.␈α⊗ If␈α⊗a␈α⊗given␈α∃system-
                                            ␈↓ π∞␈↓de␈↓βC␈↓ned␈α∂function␈α∂such␈α∂as␈α∂PLUS␈α∂is␈α∂not␈α∂to␈α∞the
                                            ␈↓ π∞␈↓user's␈α∀taste␈α∀he␈α∃can␈α∀simply␈α∀supply␈α∃his␈α∀own,
␈↓ ↓N␈↓3.␈α≥ LISP␈α≥uses␈α≤a␈α≥standard␈α≥character␈α≤set.           ␈↓ π∞␈↓without␈α
having␈αto␈α
change␈αevery␈α
occurrence␈αof
␈↓ ↓N␈↓Essentially␈α∃all␈α∃general-purpose␈α∃terminals␈α∀on    ␈↓ π∞␈↓PLUS␈αin␈αhis␈αprogram␈αto␈αa␈αuser-de␈↓βC␈↓ned␈αname.
␈↓ ↓N␈↓the␈α∂market␈α∞today␈α∂adhere␈α∞pretty␈α∂closely␈α∂to␈α∞the      ␈↓ π∞␈↓Even␈αthe␈αREAD␈α
function␈αinvoked␈αby␈αthe␈α
top-
␈↓ ↓N␈↓ASCII␈α∪standard␈α∪character␈α∪set.␈α∪ It␈α∀would␈α∪be        ␈↓ π∞␈↓level␈α∂listen␈α∂loop␈α∂can␈α∂be␈α∂replaced␈α∂with␈α⊂a␈α∂user
␈↓ ↓N␈↓next␈α⊂to␈α⊂unthinkable␈α⊂for␈α⊂a␈α⊃language␈α⊂designer       ␈↓ π∞␈↓supplied␈α∞function,␈α
an␈α∞advantage␈α∞so␈α
important
␈↓ ↓N␈↓today␈αto␈α
propose␈αa␈α
language␈αthat␈α
made␈αheavy        ␈↓ π∞␈↓that␈α
we␈αa␈↓β@␈↓ord␈α
it␈αspecial␈α
treatment␈αin␈α
the␈αnext
␈↓ ↓N␈↓use␈α∩of␈α∩a␈α∩radically␈α∩di␈↓β@␈↓erent␈α∩character␈α∩set,␈α⊃so      ␈↓ π∞␈↓section.
␈↓ ↓N␈↓this claim almost goes without saying.
                                            ␈↓ π∞␈↓LISP's␈α∂modularity␈α∞is␈α∂important␈α∞not␈α∂only␈α∂to␈α∞a
                                            ␈↓ π∞␈↓single␈α'programmer␈α'but␈α'to␈α(groups␈α'of
␈↓ ↓N␈↓4.␈α
 LISP␈α
is␈α
interactive.␈α
 If␈α
one␈α
wants␈α∞to␈α
know      ␈↓ π∞␈↓programmers␈αcooperating␈αon␈αa␈αproject.␈α When
␈↓ ↓N␈↓the␈α
value␈α
of␈α
1+1␈αwhile␈α
"talking␈α
to"␈α
LISP,␈αone       ␈↓ π∞␈↓one␈α⊃develops␈α⊃a␈α⊂LISP␈α⊃program␈α⊃for␈α⊃a␈α⊂speci␈↓βC␈↓c
␈↓ ↓N␈↓types␈α
(PLUS␈α
1␈α
1)␈αand␈α
LISP␈α
replies␈α
2␈αwithout         ␈↓ π∞␈↓application,␈α≡it␈α≡can␈α≡be␈α≡used␈α≡later␈α∨as␈α≡a
␈↓ ↓N␈↓αLISP Brief␈↓ ]4


␈↓ ↓N␈↓subroutine␈α
of␈αsomebody␈α
else's␈αprogram.␈α
 While    ␈↓ π∞␈↓ignorance,␈α
and␈αwithout␈α
making␈α
ANY␈αchanges
␈↓ ↓N␈↓this␈α→is␈α→true␈α→to␈α→a␈α→limited␈α→extent␈α→of␈α_most            ␈↓ π∞␈↓to␈α∂his␈α∞code,␈α∂we␈α∞were␈α∂able␈α∞to␈α∂accomplish␈α∂in␈α∞a
␈↓ ↓N␈↓languages,␈αit␈αholds␈αto␈α
a␈αmuch␈αgreater␈αextent␈α
in     ␈↓ π∞␈↓quite␈α⊃simple␈α⊃way␈α⊂what␈α⊃would␈α⊃require␈α⊂major
␈↓ ↓N␈↓LISP.␈α∞ When␈α
I␈α∞developed␈α
a␈α∞natural␈α
language        ␈↓ π∞␈↓surgery␈α⊂to␈α⊃the␈α⊂given␈α⊃program␈α⊂in␈α⊃almost␈α⊂any
␈↓ ↓N␈↓system␈αseveral␈α
years␈αago␈αI␈α
had␈αin␈αmind␈α
that␈αI        ␈↓ π∞␈↓other language.
␈↓ ↓N␈↓would␈α∪be␈α∪using␈α∪it␈α∪as␈α∪a␈α∪stand-alone␈α∪system.
␈↓ ↓N␈↓However␈α∞it␈α
has␈α∞found␈α
use␈α∞in␈α
the␈α∞AI␈α∞lab␈α
and
␈↓ ↓N␈↓in␈α∂LCS␈α∂as␈α∂a␈α∂subroutine␈α∂that␈α⊂other␈α∂programs         ␈↓ π∞␈↓6.␈α?␈α¬ LISP␈α?␈α¬is␈α?␈α¬notation-independent.
␈↓ ↓N␈↓can␈α∂call␈α∂to␈α∂get␈α∂the␈α∂translation␈α∂of␈α∂the␈α∞English      ␈↓ π∞␈↓Mathematically␈α
speaking,␈α
LISP␈α
programs␈α
form
␈↓ ↓N␈↓being␈α∪typed␈α∪by␈α∪the␈α∪program's␈α∪user.␈α∪ In␈α∩the         ␈↓ π∞␈↓a␈α
set␈αcontaining␈α
"atoms"␈αand␈α
closed␈α
under␈αthe
␈↓ ↓N␈↓middle␈αof␈αpreparing␈αthis␈αdocument␈αa␈αHarvard       ␈↓ π∞␈↓pairing␈αfunction␈α
CONS.␈α How␈α
such␈αprograms
␈↓ ↓N␈↓graduate␈α2student␈α2working␈α2with␈α2the               ␈↓ π∞␈↓are␈α⊃to␈α⊃be␈α⊃represented␈α⊃is␈α⊃an␈α⊃implementation-
␈↓ ↓N␈↓MACSYMA␈α∨project,␈α∨Michael␈α∨Genesereth,           ␈↓ π∞␈↓dependent␈αissue.␈α In␈αany␈αimplementation␈αthere
␈↓ ↓N␈↓came␈α∪into␈α∪my␈α∪o␈↓β@␈↓ice␈α∪to␈α∪ask␈α∪me␈α∪whether␈α∩he             ␈↓ π∞␈↓are␈α≥at␈α≥least␈α≥two␈α≥representations,␈α≤internal
␈↓ ↓N␈↓could␈αattach␈αmy␈αnatural␈αlanguage␈αfront␈αend␈αto      ␈↓ π∞␈↓(consisting␈α∞in␈α∞the␈α∞interpreted␈α∞case␈α∞of␈α∞a␈α∞graph
␈↓ ↓N␈↓his␈αMACSYMA␈αadvice-giving␈αprogram.␈α The         ␈↓ π∞␈↓whose␈α⊂nodes␈α⊂are␈α⊂computer␈α⊂words␈α⊂and␈α∂whose
␈↓ ↓N␈↓task␈α∪proved␈α∪trivial;␈α∪after␈α∪a␈α∪bit␈α∀of␈α∪ferreting      ␈↓ π∞␈↓edges␈α
are␈αpointers,␈α
and␈α
in␈αthe␈α
compiled␈αcase␈α
of
␈↓ ↓N␈↓around␈αin␈αmy␈α
␈↓βC␈↓les␈αand␈αa␈α
quick␈αdemonstration        ␈↓ π∞␈↓a␈α
string␈α
of␈αmachine␈α
instructions)␈α
and␈αexternal
␈↓ ↓N␈↓I␈α∃gave␈α∃him␈α∀the␈α∃␈↓βC␈↓le␈α∃and␈α∀the␈α∃name␈α∃of␈α∀the               ␈↓ π∞␈↓(consisting␈α∞traditionally␈α∞of␈α∞fully␈α∞parenthesized
␈↓ ↓N␈↓subroutine␈α∪to␈α∪call.␈α∩ He␈α∪went␈α∪away,␈α∪and␈α∩ten         ␈↓ π∞␈↓pre␈↓βC␈↓x␈α⊂(forward␈α⊂Polish␈α⊃notation)␈α⊂expressions).
␈↓ ↓N␈↓minutes␈α→later␈α→sent␈α→me␈α→a␈α→message␈α→on␈α→the             ␈↓ π∞␈↓However,␈α⊃this␈α⊃does␈α⊃not␈α⊃exhaust␈α⊃the␈α⊂possible
␈↓ ↓N␈↓computer␈α
expressing␈α
delight␈αthat␈α
it␈α
was␈αdoing     ␈↓ π∞␈↓representations␈α→of␈α_LISP␈α→programs␈α→by␈α_any
␈↓ ↓N␈↓just what he needed.                        ␈↓ π∞␈↓means,␈α∞a␈α∞point␈α∞that␈α∞is␈α∞frequently␈α
over-looked
                                            ␈↓ π∞␈↓and␈αyet␈αone␈αthat␈α
was␈αmade␈αright␈αat␈α
the␈αoutset
␈↓ ↓N␈↓Another␈α∞example␈α∞of␈α∞this␈α∂modularity␈α∞concerns      ␈↓ π∞␈↓by␈α≠McCarthy,␈α≠who␈α≠used␈α≠what␈α≠he␈α~called
␈↓ ↓N␈↓a␈α8program-proof-checker␈α9that␈α8Steve             ␈↓ π∞␈↓MLISP␈α∪notation,␈α∪an␈α∪algebraic␈α∪notation␈α∩that
␈↓ ↓N␈↓Litvintchouk,␈αa␈α
graduate␈αstudent␈αof␈α
mine,␈αhas     ␈↓ π∞␈↓PL/I␈αusers␈α
would␈αfeel␈αmuch␈α
more␈αcomfortable
␈↓ ↓N␈↓been␈α∞writing␈α∞in␈α∂LISP.␈α∞ He␈α∞complained␈α∂to␈α∞me         ␈↓ π∞␈↓with␈α≥than␈α≤the␈α≥fully␈α≥parenthesized␈α≤pre␈↓βC␈↓x
␈↓ ↓N␈↓that␈α∂entering␈α⊂statements␈α∂about␈α⊂programs␈α∂into     ␈↓ π∞␈↓notation.␈α An␈α
implementation␈αof␈αMLISP␈α
exists
␈↓ ↓N␈↓the␈α⊃computer␈α⊃was␈α⊃painfully␈α⊃slow␈α⊃because␈α⊃he        ␈↓ π∞␈↓at␈α
Stanford,␈α∞and␈α
is␈α
the␈α∞notation␈α
of␈α∞choice␈α
for
␈↓ ↓N␈↓was␈αusing␈αstandard␈αLISP␈αnotation.␈α So␈αI␈αmade       ␈↓ π∞␈↓LISP␈α∩users␈α∪there.␈α∩ At␈α∩MIT␈α∪an␈α∩MLISP-like
␈↓ ↓N␈↓up␈αa␈αformal␈αde␈↓βC␈↓nition␈αof␈αthe␈αnotation␈α
we␈αhad        ␈↓ π∞␈↓notation␈α↔called␈α↔CGOL␈α⊗is␈α↔available␈α↔to␈α⊗the
␈↓ ↓N␈↓been␈α≠using␈α≠in␈α≠class,␈α≠implemented␈α≤it␈α≠one           ␈↓ π∞␈↓LISP␈α
user:␈α
at␈α
any␈α
time,␈α
even␈α
half-way␈α
through
␈↓ ↓N␈↓afternoon,␈α∞loaded␈α∞it␈α∞into␈α∞a␈α∞LISP␈α∞that␈α
already      ␈↓ π∞␈↓running␈α→his␈α~program,␈α→he␈α→can␈α~simply␈α→say
␈↓ ↓N␈↓had␈α∪Litvintchouk's␈α∪program␈α∪loaded␈α∪(after␈α∩a       ␈↓ π∞␈↓(CGOL) and from then on he can rephrase
␈↓ ↓N␈↓few␈α⊂debugging␈α⊂runs␈α⊃of␈α⊂course)␈α⊂and␈α⊃we␈α⊂were          ␈↓ π∞␈↓   (QUOTIENT␈α⊂(PLUS␈α∂(MINUS␈α⊂B)␈α∂(SQRT
␈↓ ↓N␈↓then␈α_able␈α↔to␈α_talk␈α↔to␈α_his␈α↔program␈α_in␈α↔the             ␈↓ π∞␈↓␈↓ πN(DIFFERENCE␈α∩(EXPT␈α⊃B␈α∩2)(TIMES␈α⊃4
␈↓ ↓N␈↓notation␈α?␈α∃we␈α?␈α∃wanted.␈α?␈α∀ (Sample:                  ␈↓ π∞␈↓␈↓ πNA C)))) (TIMES 2 A))
␈↓ ↓N␈↓[Y:=X+5]<Y:=Y-1*>X=Y␈α≥asserts␈α≥that␈α≥after        ␈↓ π∞␈↓as
␈↓ ↓N␈↓setting␈α⊃Y␈α⊃to␈α∩X+5,␈α⊃it␈α⊃is␈α⊃possible␈α∩by␈α⊃iterating       ␈↓ π∞␈↓   (-b+sqrt(b**2-4*a*c))/(2*a)
␈↓ ↓N␈↓Y:=Y-1␈α∂to␈α∂reach␈α∂a␈α∂state␈α∂in␈α∂which␈α∂X=Y.␈α∂ We           ␈↓ π∞␈↓or
␈↓ ↓N␈↓were␈α
tiring␈αof␈α
writing␈α
(([]␈α(:=␈α
Y␈α(+␈α
X␈α
5)))␈α((<>      ␈↓ π∞␈↓   (MAPCAR␈α≡'(LAMBDA␈α≥(I␈α≡J)␈α≥(PRINT
␈↓ ↓N␈↓(*␈α⊂(:=␈α⊂Y␈α⊂(-␈α⊂Y␈α⊂1))))␈α⊂(=␈α⊂X␈α⊂Y)))␈α⊂to␈α⊂express␈α⊂the           ␈↓ π∞␈↓␈↓ πN(CAT␈α∀'|Buy␈α∪|␈α∀I␈α∪'|␈α∀for␈α∪|␈α∀J␈α∀'|␈α∪dollars.|)))
␈↓ ↓N␈↓same␈α
thing.)␈αThe␈α
remarkable␈αthing␈α
about␈αthis      ␈↓ π∞␈↓␈↓ πNSHOPPINGLIST PRICELIST)
␈↓ ↓N␈↓particular␈α
exercise␈αis␈α
that␈α
I␈αhad␈α
no␈α
idea␈αwhat      ␈↓ π∞␈↓as
␈↓ ↓N␈↓his␈α∞code␈α
looked␈α∞like␈α∞at␈α
the␈α∞time␈α
as␈α∞I␈α∞had␈α
not         ␈↓ π∞␈↓   for i in shoppinglist, j in pricelist do
␈↓ ↓N␈↓then␈α
gotten␈α
around␈α
to␈α
reading␈α
it,␈α
and␈α
he␈α
had        ␈↓ π∞␈↓      print "Buy " ↑ i ↑ " for " ↑ j ↑ " dollars."
␈↓ ↓N␈↓no␈α≥idea␈α≥how␈α≤one␈α≥went␈α≥about␈α≤changing               ␈↓ π∞␈↓and␈α~so␈α≠on.␈α~ The␈α≠versatility␈α~of␈α≠LISP␈α~in
␈↓ ↓N␈↓notation␈α∀in␈α∃LISP.␈α∀ Yet␈α∀despite␈α∃this␈α∀mutual        ␈↓ π∞␈↓comparison␈α"to␈α"most␈α"other␈α"programming
␈↓ ↓N␈↓αLISP Brief␈↓ ←5


␈↓ ↓N␈↓languages␈α→becomes␈α→more␈α→apparent␈α→in␈α→this          ␈↓ π∞␈↓arrays␈α
ind[1:n]␈α
and␈αorb[1:n]␈α
to␈α
store␈αthe␈α
results
␈↓ ↓N␈↓notation␈α∞because␈α∂a␈α∞more␈α∞direct␈α∂comparison␈α∞is      ␈↓ π∞␈↓in.␈α≥ Town␈α≤i␈α≥is␈α≤to␈α≥be␈α≤in␈α≥the␈α≤ind[i]-th
␈↓ ↓N␈↓possible␈α⊂without␈α∂the␈α⊂distraction␈α∂of␈α⊂having␈α∂to     ␈↓ π∞␈↓equivalence␈α∩class.␈α∪ Orb[i]␈α∩is␈α∪a␈α∩list␈α∪of␈α∩towns
␈↓ ↓N␈↓allow␈α∞for␈α
radically␈α∞di␈↓β@␈↓erent␈α
styles␈α∞of␈α
notation.  ␈↓ π∞␈↓arranged␈αso␈αthat␈αeach␈αequivalence␈αclass␈αis␈αin␈αa
␈↓ ↓N␈↓(An␈α*aside:␈α)although␈α*all␈α)programming             ␈↓ π∞␈↓contiguous␈α∞block;␈α∞the␈α
␈↓βC␈↓rst␈α∞town␈α∞of␈α∞each␈α
block
␈↓ ↓N␈↓languages␈α∞deserving␈α∞of␈α∞the␈α∞name␈α∂can␈α∞express       ␈↓ π∞␈↓is␈α⊃stored␈α⊃with␈α∩its␈α⊃sign␈α⊃bit␈α∩complemented␈α⊃(in
␈↓ ↓N␈↓the␈α∞␈↓βC␈↓rst␈α
of␈α∞the␈α∞above␈α
examples,␈α∞very␈α∞few␈α
can        ␈↓ π∞␈↓particular␈α
town␈α1␈α
will␈α
appear␈αin␈α
orb[1]␈α
as␈α-1)
␈↓ ↓N␈↓cope with the second quite so directly.)    ␈↓ π∞␈↓to distinguish the beginning of the block.

␈↓ ↓N␈↓The␈α+CGOL␈α+notation␈α,inherits␈α+LISP's               ␈↓ π∞␈↓(The␈αproblem␈αwas␈αstated␈αin␈αCACM␈αin␈αgroup-
␈↓ ↓N␈↓modularity,␈α≡in␈α≥that␈α≡it␈α≥can␈α≡be␈α≥extended            ␈↓ π∞␈↓theoretic␈αterms,␈αwith␈αorb␈αreferring␈αto␈α
orbits␈αof
␈↓ ↓N␈↓painlessly␈α_by␈α_the␈α↔user␈α_even␈α_while␈α_in␈α↔the           ␈↓ π∞␈↓group␈α_elements,␈α_but␈α_the␈α_ALGOL␈α_solution
␈↓ ↓N␈↓middle␈αof␈αrunning␈αa␈αprogram.␈α This␈α
legacy␈αof       ␈↓ π∞␈↓given␈α_in␈α_CACM␈α↔solves␈α_the␈α_more␈α↔general
␈↓ ↓N␈↓LISP's␈α⊂puts␈α⊂this␈α⊂algebraic␈α⊂notation␈α⊂ahead␈α⊂of      ␈↓ π∞␈↓problem we have just described.)
␈↓ ↓N␈↓almost␈α1all␈α1other␈α1available␈α0algebraic            ␈↓ π∞␈↓␈↓αprocedure␈↓ orbits(ind, orb, im, n, k);
␈↓ ↓N␈↓programming␈α#languages␈α#with␈α#respect␈α"to           ␈↓ π∞␈↓  ␈↓αvalue␈↓ n, k; ␈↓αinteger␈↓ n, k;
␈↓ ↓N␈↓syntactic␈α∀extensibility.␈α∪ Only␈α∀a␈α∀few␈α∪research    ␈↓ π∞␈↓  ␈↓αinteger␈↓ ␈↓αarray␈↓ ind, orb, im;
␈↓ ↓N␈↓systems␈αcome␈αclose␈α
to␈αthis␈αlevel␈αof␈α
convenience,   ␈↓ π∞␈↓␈↓αbegin␈↓
␈↓ ↓N␈↓such␈α∂as␈α∂Bell␈α∂Laboratories'␈α⊂recently␈α∂developed    ␈↓ π∞␈↓  ␈↓αinteger␈↓ q, r, s, j, nt, ns, norb;
␈↓ ↓N␈↓YACC␈α∨(Yet␈α Another␈α∨Compiler-Compiler)           ␈↓ π∞␈↓  ␈↓αfor␈↓ j := 1 ␈↓αstep␈↓ 1 ␈↓αuntil␈↓ n ␈↓αdo␈↓ ind[j] := 0;
␈↓ ↓N␈↓system,␈α
a␈αversion␈α
of␈αwhich␈α
has␈αbeen␈α
developed      ␈↓ π∞␈↓  norb := 0; ns := 1;
␈↓ ↓N␈↓by␈α⊂Alan␈α⊂Snyder␈α⊂at␈α⊂MIT␈α⊂and␈α⊂is␈α⊂used␈α⊂as␈α∂the             ␈↓ π∞␈↓  ␈↓αfor␈↓␈α⊂r␈α∂:=␈α⊂1␈α∂␈↓αstep␈↓␈α⊂1␈α∂␈↓αuntil␈↓␈α⊂n␈α∂␈↓αdo␈↓␈α⊂␈↓αif␈↓␈α∂ind[r]␈α⊂=␈α∂0
␈↓ ↓N␈↓"front-end"␈α'of␈α'Barbara␈α'Liskov's␈α'CLU             ␈↓ π∞␈↓␈↓ πN␈↓αthen␈↓
␈↓ ↓N␈↓language␈α≠at␈α≠MIT.␈α≠ Even␈α≤these␈α≠advanced            ␈↓ π∞␈↓  ␈↓αbegin␈↓
␈↓ ↓N␈↓systems␈α&do␈α¬␈α&o␈↓β@␈↓er␈α&fast␈α%incremental             ␈↓ π∞␈↓    norb := norb + 1; ind[r] := norb;
␈↓ ↓N␈↓extensibility␈α→of␈α_this␈α→syntactic␈α→front-end␈α_to     ␈↓ π∞␈↓    nt := ns; orb[ns] := -r; s := r;
␈↓ ↓N␈↓LISP [6,8].                                 ␈↓ π∞␈↓a:
                                            ␈↓ π∞␈↓    ns := ns + 1;
␈↓ ↓N␈↓It␈α
may␈α
be␈α
instructive␈α
to␈α
compare␈α∞an␈α
ALGOL          ␈↓ π∞␈↓    ␈↓αfor␈↓ j := 1 ␈↓αstep␈↓ 1 ␈↓αuntil␈↓ k ␈↓αdo␈↓
␈↓ ↓N␈↓program␈α5taken␈α4verbatim␈α5from␈α4the                 ␈↓ π∞␈↓    ␈↓αbegin␈↓
␈↓ ↓N␈↓Communications␈α#of␈α#the␈α$Association␈α#for           ␈↓ π∞␈↓      q := im[s,j];
␈↓ ↓N␈↓Computing␈α→Machinery,␈α_Algorithm␈α→482␈α_[3],         ␈↓ π∞␈↓      ␈↓αif␈↓ ind[q] = 0 ␈↓αthen␈↓
␈↓ ↓N␈↓with␈α∞its␈α∞rendering␈α∞in␈α∞this␈α∞algebraic␈α∂dialect␈α∞of    ␈↓ π∞␈↓      ␈↓αbegin␈↓
␈↓ ↓N␈↓LISP.␈α∃ We␈α∃give␈α∃the␈α∃ALGOL␈α∃version␈α∀␈↓βC␈↓rst,            ␈↓ π∞␈↓        nt := nt + 1; orb[nt] := q; ind[q] := norb
␈↓ ↓N␈↓changing␈αonly␈α
its␈αcomment␈α
section␈αfor␈αthe␈α
sake     ␈↓ π∞␈↓      ␈↓αend␈↓
␈↓ ↓N␈↓of␈α⊃brevity.␈α⊂ comment␈α⊃We␈α⊂are␈α⊃given␈α⊂a␈α⊃set␈α⊂of          ␈↓ π∞␈↓    ␈↓αend␈↓;
␈↓ ↓N␈↓towns␈αnumbered␈α1␈αto␈αn.␈α There␈αare␈αk␈αone-way         ␈↓ π∞␈↓    ␈↓αif␈↓ ns ≤ nt ␈↓αthen␈↓
␈↓ ↓N␈↓roads␈αleading␈αout␈αof␈αeach␈αtown␈αin␈αsuch␈αa␈αway         ␈↓ π∞␈↓    ␈↓αbegin␈↓ s := orb[ns]; ␈↓αgo␈↓ ␈↓αto␈↓ a ␈↓αend␈↓
␈↓ ↓N␈↓that␈α∞if␈α∞you␈α∞ever␈α∞go␈α
on␈α∞a␈α∞trip␈α∞you␈α∞can␈α
always          ␈↓ π∞␈↓  ␈↓αend␈↓
␈↓ ↓N␈↓get␈α⊂back␈α⊂home␈α⊂again,␈α⊂though␈α⊂not␈α⊂necessarily       ␈↓ π∞␈↓␈↓αend␈↓
␈↓ ↓N␈↓by␈α∩retracing␈α∩your␈α∩steps.␈α∩ However,␈α∩it␈α∪is␈α∩not
␈↓ ↓N␈↓guaranteed␈α∀that␈α∀you␈α∀can␈α∀always␈α∀get␈α∀to␈α∪the          ␈↓ π∞␈↓The␈α⊃following␈α⊂is␈α⊃the␈α⊂LISP␈α⊃rendering␈α⊃of␈α⊂the
␈↓ ↓N␈↓town␈αof␈αyour␈αchoice.␈α The␈αproblem␈αis␈αto␈α
group       ␈↓ π∞␈↓above␈α⊃procedure,␈α⊂using␈α⊃the␈α⊃algebraic␈α⊂dialect.
␈↓ ↓N␈↓the␈α
towns␈αinto␈α
equivalence␈αclasses␈α
of␈αmutually    ␈↓ π∞␈↓For␈α∪direct␈α∀comparison␈α∪we␈α∪have␈α∀adhered␈α∪as
␈↓ ↓N␈↓accessible towns.                           ␈↓ π∞␈↓closely␈α∞as␈α∂possible␈α∞to␈α∞the␈α∂layout␈α∞of␈α∂the␈α∞above
                                            ␈↓ π∞␈↓program.
␈↓ ↓N␈↓The␈αroads␈αare␈αrepresented␈αby␈αan␈αarray␈αim[1:n,      ␈↓ π∞␈↓de␈↓βC␈↓ne "ORBITS"(ind, orb, im, n, k);
␈↓ ↓N␈↓1:k]␈α~such␈α~that␈α≠im[r,q]␈α~is␈α~the␈α≠q-th␈α~town            ␈↓ π∞␈↓(
␈↓ ↓N␈↓accessible␈α∩from␈α∩town␈α∩r.␈α∩ You␈α∩are␈α∩given␈α⊃two         ␈↓ π∞␈↓  new q, r, s, j, nt, ns, norb;
                                            ␈↓ π∞␈↓  for j in 1 to n do ind(j) := 0;
␈↓ ↓N␈↓αLISP Brief␈↓ `6


␈↓ ↓N␈↓  norb := 0; ns := 1;                       ␈↓ π∞␈↓least␈α≡for␈α≡this␈α≡example␈α≡(where␈α∨we␈α≡were
␈↓ ↓N␈↓  for r in 1 to n do if ind(r) = 0 then     ␈↓ π∞␈↓fortunate␈α∪that␈α∪we␈α∪could␈α∀translate␈α∪ALGOL's
␈↓ ↓N␈↓  (prog;␈α%␈αnecessitated␈αby␈αthe␈αpresence␈αof␈α
(ugh)   ␈↓ π∞␈↓␈↓αgoto␈↓␈α⊃directly;␈α⊃␈↓αgoto␈↓'s␈α∩out␈α⊃of␈α⊃blocks␈α∩require␈α⊃a
␈↓ ↓N␈↓␈↓ α∞goto %                                      ␈↓ π∞␈↓more␈α≡involved␈α≡translation␈α≡into␈α≡LISP␈α≡in
␈↓ ↓N␈↓    norb := norb + 1; ind(r) := norb;       ␈↓ π∞␈↓general,␈α∞as␈α∞does␈α∞call␈α
by␈α∞name.)␈α∞However␈α∞I␈α
do
␈↓ ↓N␈↓    nt := ns; orb(ns) := -r; s := r;        ␈↓ π∞␈↓not␈α∂foresee␈α∂frequent␈α∂use␈α∂being␈α∂made␈α∂of␈α∂such
␈↓ ↓N␈↓a;                                          ␈↓ π∞␈↓modi␈↓α␈↓βC␈↓α␈↓cations to the notation.
␈↓ ↓N␈↓    ns := ns + 1;
␈↓ ↓N␈↓    for j in 1 to k do                      ␈↓ π∞␈↓The␈αabove␈αcomparison␈αis␈αa␈αlittle␈αlike␈αhaving␈α
a
␈↓ ↓N␈↓    (                                       ␈↓ π∞␈↓race␈αbetween␈αa␈αFord␈αand␈αa␈αPorsche␈αwhere␈αthe
␈↓ ↓N␈↓      q := im(s,j);                         ␈↓ π∞␈↓drivers␈α↔are␈α⊗required␈α↔to␈α↔behave␈α⊗identically.
␈↓ ↓N␈↓      if ind(q) = 0 then                    ␈↓ π∞␈↓After␈α∞a␈α
few␈α∞seconds␈α
the␈α∞Porsche␈α∞driver␈α
starts
␈↓ ↓N␈↓      (                                     ␈↓ π∞␈↓to␈αgrumble␈αabout␈αbeing␈αin␈αthird␈αgear␈αwhen␈αhe
␈↓ ↓N␈↓        nt := nt + 1; orb(nt) := q; ind(q) := norb␈↓ π∞␈↓should␈α
be␈α
in␈α
␈↓α␈↓βC␈↓α␈↓fth.␈α
 In␈α
the␈α
above␈α
example␈α
there
␈↓ ↓N␈↓      )                                     ␈↓ π∞␈↓is␈α
some␈α
clumsy␈α
programming␈α
going␈α
on␈α
that␈αis
␈↓ ↓N␈↓    );                                      ␈↓ π∞␈↓the␈α
result␈α
of␈α
programming␈α
in␈α
a␈α
language␈αthat
␈↓ ↓N␈↓    if ns <= nt then                        ␈↓ π∞␈↓does␈α∀not␈α∀provide␈α∀adequately␈α∀for␈α∀irregularly
␈↓ ↓N␈↓    ( s := orb(ns); go a )                  ␈↓ π∞␈↓structured␈α∪data.␈α∪ Actually,␈α∩the␈α∪input␈α∪of␈α∩this
␈↓ ↓N␈↓  )                                         ␈↓ π∞␈↓example␈α(the␈αarray␈αim)␈αis␈α
regularly␈αstructured,
␈↓ ↓N␈↓)                                           ␈↓ π∞␈↓but␈αthe␈αresult␈α
(the␈αarray␈αorb)␈αattempts␈α
clumsily
                                            ␈↓ π∞␈↓(using␈α
the␈α
sign␈α
bits␈α
of␈α
its␈α
entries)␈α
to␈αrepresent
␈↓ ↓N␈↓The only di␈↓β@␈↓erences in this example are:    ␈↓ π∞␈↓the irregularly structured answer.
␈↓ ↓N␈↓    ALGOL ␈↓ β↑    LISP
␈↓ ↓N␈↓a[b] ␈↓ β↑a(b) ␈↓ ∧N(␈↓αarray␈↓s)                          ␈↓ π∞␈↓We␈α⊂give␈α⊂below␈α⊃another␈α⊂version␈α⊂of␈α⊃the␈α⊂same
␈↓ ↓N␈↓␈↓αbegin␈↓ ␈↓αend␈↓ ␈↓ β↑( ) ␈↓ ∧N(block delimiters)            ␈↓ π∞␈↓algorithm,␈α∃this␈α∀time␈α∃relaxing␈α∃the␈α∀constraint
␈↓ ↓N␈↓␈↓αinteger␈↓ ␈↓ β↑new ␈↓ ∧N(type                           ␈↓ π∞␈↓that␈α∂we␈α∂have␈α∞to␈α∂mimic␈α∂the␈α∂ALGOL␈α∞solution
␈↓ ↓N␈↓␈↓ ∧}declarations                                ␈↓ π∞␈↓as␈α⊃closely␈α⊂as␈α⊃possible.␈α⊂ First␈α⊃we␈α⊃observe␈α⊂that
␈↓ ↓N␈↓␈↓ ∧}inessential)                                ␈↓ π∞␈↓the␈α∀array␈α∀im␈α∀is␈α∪really␈α∀the␈α∀only␈α∀input␈α∪data
␈↓ ↓N␈↓␈↓αprocedure␈↓ ␈↓ β↑de␈↓α␈↓βC␈↓α␈↓ne                             ␈↓ π∞␈↓required.␈α_ Second,␈α→we␈α_suggest␈α_that␈α→im␈α_be
␈↓ ↓N␈↓  (and related text) ␈↓ β↑  (and related text)   ␈↓ π∞␈↓represented␈α∀as␈α∀a␈α∀vector␈α∀of␈α∀lists,␈α∀allowing␈α∪a
␈↓ ↓N␈↓␈↓αfor␈↓ i := 1 ␈↓αstep␈↓ 1 ␈↓ β↑␈↓αfor␈↓ i in 1 ␈↓αto␈↓ n           ␈↓ π∞␈↓variable␈α
number␈α
of␈α
roads␈α
to␈α
leave␈α
each␈αtown.
␈↓ ↓N␈↓  ␈↓αuntil␈↓ n                                   ␈↓ π∞␈↓(In␈α∀the␈α∃group-theoretic␈α∀special␈α∀case␈α∃of␈α∀this
␈↓ ↓N␈↓a: (and associated ␈↓ β↑a; (and associated       ␈↓ π∞␈↓problem,␈αk␈αis␈α␈↓α␈↓βC␈↓α␈↓xed,␈αcorresponding␈αto␈αhaving␈αk
␈↓ ↓N␈↓  ␈↓αgo␈↓␈↓αto␈↓) ␈↓ β↑  prog and ␈↓αgo␈↓)                      ␈↓ π∞␈↓generators␈α∀of␈α∀an␈α∀n␈α∀element␈α∀group,␈α∀but␈α∪the
␈↓ ↓N␈↓␈↓αvalue␈↓ ␈↓ β↑redundant␈α≥(␈↓αarray␈↓s␈α≥may                   ␈↓ π∞␈↓solution␈α⊂given␈α⊂in␈α⊂CACM␈α⊂makes␈α⊂no␈α⊂essential
␈↓ ↓N␈↓␈↓ ∧}be␈α∀␈↓αvalue␈↓s␈α∀in                                  ␈↓ π∞␈↓use␈α∂of␈α∞k␈α∂being␈α∞␈↓α␈↓βC␈↓α␈↓xed.)␈α∂Third,␈α∞we␈α∂suggest␈α∞that
␈↓ ↓N␈↓␈↓ ∧}LISP)                                       ␈↓ π∞␈↓the␈α
answer␈α
be␈α
an␈α
array␈α
(corresponding␈α
to␈α
ind
␈↓ ↓N␈↓≤ ␈↓ β↑<=␈α (≥␈α not␈α!in␈α ASCII                            ␈↓ π∞␈↓in␈α∞the␈α∂above␈α∞program)␈α∂whose␈α∞i-th␈α∂element␈α∞is
␈↓ ↓N␈↓␈↓ ∧}standard)                                   ␈↓ π∞␈↓the␈α→list␈α~of␈α→towns␈α~accessible␈α→from␈α~town␈α→i
                                            ␈↓ π∞␈↓(numbering␈α⊃these␈α⊃equivalence␈α⊃lists␈α⊃as␈α∩in␈α⊃the
␈↓ ↓N␈↓Except␈α∂for␈α∞␈↓αvalue␈↓␈α∂and␈α∞≤,␈α∂the␈α∞␈↓α␈↓βC␈↓α␈↓rst␈α∂of␈α∂which␈α∞is         ␈↓ π∞␈↓above programs seems pointless).
␈↓ ↓N␈↓redundant␈α
in␈α
LISP␈αand␈α
the␈α
second␈α
of␈αwhich␈α
is
␈↓ ↓N␈↓not␈αavailable␈αin␈αthe␈αstandard␈αASCII␈αcharacter     ␈↓ π∞␈↓All␈α∞variables␈α∞except␈α∞adi␈α∞(array␈α∞dimensions␈α
of
␈↓ ↓N␈↓set,␈α
none␈α
of␈α
these␈α
di␈↓α␈↓β@␈↓α␈↓erences␈α
are␈α
essential;␈αthe   ␈↓ π∞␈↓im)␈αcorrespond␈αto␈αvariables␈αused␈αin␈αthe␈αabove
␈↓ ↓N␈↓CGOL␈αnotation,␈αbeing␈αuser␈αextensible,␈α
can␈αbe      ␈↓ π∞␈↓programs,␈α
though␈α
they␈αmay␈α
not␈α
be␈α
of␈αthe␈α
same
␈↓ ↓N␈↓modi␈↓α␈↓βC␈↓α␈↓ed␈α∞either␈α∂by␈α∞the␈α∂individual␈α∞user,␈α∂or␈α∞by       ␈↓ π∞␈↓type.
␈↓ ↓N␈↓the␈α∪system␈α∪programmers␈α∪when␈α∪a␈α∪su␈↓α␈↓β@␈↓α␈↓iciently        ␈↓ π∞␈↓de␈↓α␈↓βC␈↓α␈↓ne "ORBITS" im;
␈↓ ↓N␈↓large␈α∞demand␈α∞exists,␈α∞to␈α∞permit␈α∞the␈α∞use␈α∞of␈α
the       ␈↓ π∞␈↓let adi = arraydims im;
␈↓ ↓N␈↓␈↓α␈↓βC␈↓α␈↓rst␈αseven␈αof␈αthe␈αabove␈αALGOL␈αconstructs,␈αat       ␈↓ π∞␈↓let␈α
ind␈α=␈α
array{nil␈α.␈α
adi},␈αn␈α
=␈αcadr␈α
adi␈α-␈α
1,␈αnt␈α
=
                                            ␈↓ π∞␈↓␈↓ πNnil;
␈↓ ↓N␈↓αLISP Brief␈↓ `7


␈↓ ↓N␈↓for r in 1 to n do if null ind(r) then      ␈↓ π∞␈↓parser␈α∀modi␈↓α␈↓βC␈↓α␈↓ed␈α∪(by␈α∀Michael␈α∀Genesereth)␈α∪to
␈↓ ↓N␈↓  (ind(r) := nt := [r];                     ␈↓ π∞␈↓handle␈α⊃typed␈α⊂expressions.␈α⊃ Unlike␈α⊃CGOL␈α⊂in
␈↓ ↓N␈↓   for s in ind(r) do                       ␈↓ π∞␈↓plain␈α≠LISP,␈α≠MACSYMA␈α≠notation␈α≠is␈α≠the
␈↓ ↓N␈↓      for q in im(s) do if null ind(q) then ␈↓ π∞␈↓default language for MACSYMA users.
␈↓ ↓N␈↓        (ind(q)␈α
:=␈α
ind(r);␈α
cdr␈α∞nt␈α
:=␈α
[q];␈α
nt␈α∞:=␈α
cdr
␈↓ ↓N␈↓␈↓ α∞nt));                                       ␈↓ π∞␈↓It␈α~must␈α≠be␈α~admitted␈α~that␈α≠any␈α~notational
␈↓ ↓N␈↓ind                                         ␈↓ π∞␈↓change␈α⊃to␈α⊃LISP␈α⊃raises␈α⊃the␈α⊃question␈α⊃of␈α⊂what
                                            ␈↓ π∞␈↓constitutes␈α⊗a␈α⊗programming␈α↔language.␈α⊗ Must
␈↓ ↓N␈↓The␈α∩outermost␈α⊃for-loop␈α∩looks␈α⊃for␈α∩towns␈α⊃not        ␈↓ π∞␈↓one␈α∞buy␈α∞lexicon,␈α
syntax,␈α∞semantics␈α∞and␈α
object
␈↓ ↓N␈↓yet␈α↔in␈α↔equivalence␈α↔classes␈α↔(LISP␈α↔initializes     ␈↓ π∞␈↓code␈α⊂as␈α⊃a␈α⊂package,␈α⊂or␈α⊃can␈α⊂one␈α⊃shop␈α⊂around
␈↓ ↓N␈↓untyped␈α∀arrays␈α∀to␈α∪NIL,␈α∀whence␈α∀the␈α∪NULL            ␈↓ π∞␈↓like␈α
a␈α
purchaser␈α
of␈α
a␈α
component␈α∞stereo?␈α
 The
␈↓ ↓N␈↓test).␈α When␈αa␈αnew␈α
town␈αr␈αis␈αfound,␈α
a␈αlength-        ␈↓ π∞␈↓argument␈αof␈αthis␈αsection␈αhas␈αassumed␈αthat␈αone
␈↓ ↓N␈↓one␈αequivalence␈αlist␈α[r]␈αis␈αstarted␈αfor␈αit,␈αand␈αnt   ␈↓ π∞␈↓␈↓↓can␈↓␈α∃shop␈α∃around,␈α∃but␈α∃I␈α∃realize␈α⊗that␈α∃while
␈↓ ↓N␈↓is␈α∂set␈α∂to␈α∂the␈α∂last␈α∂LISP␈α∂cell␈α∂of␈α∂the␈α∂list␈α∞(which       ␈↓ π∞␈↓component␈α_stereos␈α_may␈α_make␈α_sense␈α_to␈α↔an
␈↓ ↓N␈↓initially␈α
is␈αalso␈α
the␈α␈↓α␈↓βC␈↓α␈↓rst).␈α
 Then␈αfor␈α
each␈αtown    ␈↓ π∞␈↓electrical␈α⊂engineer,␈α⊃the␈α⊂concept␈α⊃of␈α⊂component
␈↓ ↓N␈↓s␈α
on␈α
the␈α
list,␈α
towns␈α
reachable␈α
from␈α
s␈α
that␈α
as␈α
yet     ␈↓ π∞␈↓languages␈αmay␈αrequire␈αsome␈αgetting␈αused␈αto.␈α I
␈↓ ↓N␈↓belong␈αto␈αno␈αlist␈αare␈αput␈αat␈αthe␈αend␈αof␈αthis␈α
list.     ␈↓ π∞␈↓feel␈α$that␈α$this␈α$issue␈α$drives␈α$home␈α#the
␈↓ ↓N␈↓(Since␈α↔"for␈α⊗s␈α↔in␈α↔ind(r)"␈α⊗does␈α↔not␈α↔make␈α⊗a            ␈↓ π∞␈↓disadvantage␈α→of␈α→most␈α→languages,␈α→that␈α_you
␈↓ ↓N␈↓separate␈αcopy␈αof␈α
the␈αlist␈αind(r)␈αbefore␈α
scanning   ␈↓ π∞␈↓cannot␈αuse␈αit␈αfor␈αits␈αgood␈αfeatures␈αwithout␈α
also
␈↓ ↓N␈↓it,␈α∂putting␈α∂more␈α∞towns␈α∂on␈α∂the␈α∞end␈α∂of␈α∂the␈α∞list        ␈↓ π∞␈↓having␈α≠to␈α~accept␈α≠its␈α~bad␈α≠features.␈α~ This
␈↓ ↓N␈↓forces␈α
the␈α
for-loop␈α
to␈α
consider␈α
those␈α∞towns␈α
as     ␈↓ π∞␈↓situation␈α∩has␈α∩encouraged␈α∩an␈α∪attitude␈α∩among
␈↓ ↓N␈↓well,␈α⊃which␈α⊃is␈α⊂what␈α⊃we␈α⊃want␈α⊃here.␈α⊂ Though          ␈↓ π∞␈↓language␈α∞users␈α∞that␈α∞permits␈α∞arguments␈α∞of␈α∞the
␈↓ ↓N␈↓this␈α∪is␈α∪not␈α∪good␈α∪LISP␈α∪style,␈α∪it␈α∪is␈α∀how␈α∪one           ␈↓ π∞␈↓form,␈α
"We␈α
can't␈αhave␈α
X␈α
because␈αit␈α
has␈α
a␈αbad
␈↓ ↓N␈↓would␈α∞use␈α∞LISP␈α∞to␈α∞do␈α∞what␈α∞was␈α∞done␈α∂in␈α∞the            ␈↓ π∞␈↓feature,␈α∞namely␈α∞its␈α∞syntax."␈α∞As␈α∞the␈α∞computer-
␈↓ ↓N␈↓ALGOL␈α∀program,␈α∃which␈α∀is␈α∀not␈α∃good␈α∀style            ␈↓ π∞␈↓using␈α
community␈α
matures,␈α
it␈α
should␈α
grow␈α
more
␈↓ ↓N␈↓either.)␈α⊃When␈α⊃all␈α⊃towns␈α⊃have␈α⊃been␈α∩put␈α⊃into         ␈↓ π∞␈↓accustomed␈α
to␈α
the␈α
idea␈α
of␈αpurchasing␈α
language
␈↓ ↓N␈↓classes,␈α
the␈α
array␈α
ind␈α
is␈α
returned.␈α
 To␈α∞use␈α
the     ␈↓ π∞␈↓components␈α∪and␈α∪assembling␈α∪them␈α∪into␈α∩their
␈↓ ↓N␈↓subroutine␈α∞on␈α
input␈α∞array␈α
x␈α∞to␈α
␈↓α␈↓βC␈↓α␈↓nd␈α∞out␈α
what         ␈↓ π∞␈↓"ideal"␈αsystem.␈α As␈αa␈αspin-o␈↓↓␈↓β@␈↓↓␈↓␈αfrom␈αthis␈αsort␈αof
␈↓ ↓N␈↓towns␈α∂are␈α∞accessible␈α∂from␈α∞town␈α∂i,␈α∂say␈α∞"(orbits     ␈↓ π∞␈↓technology,␈α∞we␈α
may␈α∞hope␈α
to␈α∞see␈α
a␈α∞decrease␈α
in
␈↓ ↓N␈↓x)(i)"␈α⊂which␈α⊂will␈α⊂compute␈α⊂the␈α⊂ind␈α⊃array␈α⊂and        ␈↓ π∞␈↓the␈α
number␈α
of␈α
languages␈α
available,␈α
a␈α
number
␈↓ ↓N␈↓then␈α⊗apply␈α∃it␈α⊗to␈α∃i.␈α⊗ This␈α∃of␈α⊗course␈α⊗is␈α∃an            ␈↓ π∞␈↓which␈α
from␈α
this␈α
point␈α
of␈α
view␈α
we␈α
can␈α
attribute
␈↓ ↓N␈↓ine␈↓α␈↓β@␈↓α␈↓icient␈α∩use␈α∩of␈α∩ORBITS;␈α∩usually␈α∩one␈α⊃will        ␈↓ π∞␈↓to␈α∀the␈α∀multiplicative␈α∀way␈α∀in␈α∃which␈α∀options
␈↓ ↓N␈↓say␈α"x␈α:=␈αorbits␈αy"␈αand␈αlater␈αsay␈α"x(i)"␈αfor␈αeach     ␈↓ π∞␈↓must␈α∞increase␈α∞when␈α∞you␈α∞cannot␈α∞order␈α
systems
␈↓ ↓N␈↓i of interest.                              ␈↓ π∞␈↓component␈αby␈αcomponent.␈α For␈αexample,␈αif␈α
the
                                            ␈↓ π∞␈↓community␈α∃demands␈α∃two␈α∃kinds␈α∃of␈α∀lexicons,
␈↓ ↓N␈↓For␈α
those␈α
readers␈α
wondering␈α
how␈α
hard␈α
I␈α
had         ␈↓ π∞␈↓two␈α⊃kinds␈α⊂of␈α⊃syntax,␈α⊂two␈α⊃kinds␈α⊃of␈α⊂semantics
␈↓ ↓N␈↓to␈α∩look␈α∩to␈α∩␈↓α␈↓βC␈↓α␈↓nd␈α∩an␈α∩example␈α∩better␈α∪coded␈α∩in           ␈↓ π∞␈↓and␈α
two␈α∞kinds␈α
of␈α
code-generators,␈α∞the␈α
market
␈↓ ↓N␈↓LISP␈α↔than␈α↔ALGOL,␈α↔I␈α↔should␈α↔say␈α_that␈α↔I               ␈↓ π∞␈↓need␈αsupply␈αonly␈αeight␈αcomponents␈αin␈αplace␈αof
␈↓ ↓N␈↓simply␈α
selected␈αthe␈α
most␈αrecent␈α
short␈αALGOL       ␈↓ π∞␈↓sixteen␈α∂systems.␈α∂ Any␈α∂increase␈α∂in␈α∂the␈α∂sizes␈α∞of
␈↓ ↓N␈↓contribution␈α↔to␈α⊗CACM's␈α↔algorithms␈α⊗section       ␈↓ π∞␈↓the␈α_component␈α_options␈α_results␈α_in␈α_a␈α_rapid
␈↓ ↓N␈↓that␈αI␈α
could␈α␈↓α␈↓βC␈↓α␈↓nd␈αon␈α
my␈αbookshelf.␈α I␈α
originally     ␈↓ π∞␈↓widening of this gap.
␈↓ ↓N␈↓had␈α∪not␈α∪intended␈α∪to␈α∪give␈α∪the␈α∀second␈α∪LISP
␈↓ ↓N␈↓version,␈α∞but␈α∂could␈α∞not␈α∞resist␈α∂it␈α∞once␈α∂I␈α∞␈↓α␈↓βC␈↓α␈↓gured      ␈↓ π∞␈↓In␈α∀this␈α∀context␈α∀the␈α∀question␈α∀of␈α∀whether␈α∪to
␈↓ ↓N␈↓out what the algorithm was up to.           ␈↓ π∞␈↓choose␈α≠a␈α≠widely␈α≠used␈α≠language␈α≤must␈α≠be
                                            ␈↓ π∞␈↓restated␈α⊃as␈α⊂whether␈α⊃to␈α⊂choose␈α⊃a␈α⊃widely␈α⊂used
␈↓ ↓N␈↓CGOL␈α∪is␈α∀not␈α∪the␈α∀only␈α∪algebraic␈α∀dialect␈α∪of          ␈↓ π∞␈↓component.␈α∀ This␈α∃question␈α∀is␈α∃perhaps␈α∀most
␈↓ ↓N␈↓LISP␈α∩available␈α∩at␈α∩MIT.␈α∩ MACSYMA␈α⊃users            ␈↓ π∞␈↓important␈α∪for␈α∀the␈α∪syntax␈α∀component,␈α∪which
␈↓ ↓N␈↓also␈α⊂use␈α∂an␈α⊂MLISP-like␈α∂algebraic␈α⊂notation␈α∂-       ␈↓ π∞␈↓for␈α⊃the␈α⊃user␈α⊃is␈α⊃as␈α⊃at␈α⊃least␈α⊃as␈α⊃visible␈α⊃as␈α⊂any
␈↓ ↓N␈↓in␈α
fact␈α
MACSYMA's␈α
parser␈α
is␈α
just␈αthe␈α
CGOL          ␈↓ π∞␈↓other␈αcomponent.␈α
 Although␈αI␈αsuggested␈α
above
␈↓ ↓N␈↓αLISP Brief␈↓ ←8


␈↓ ↓N␈↓that␈α⊗CGOL␈α⊗or␈α∃MACSYMA␈α⊗notation␈α⊗is␈α∃a                ␈↓ π∞␈↓MAPCAR␈αpermits␈αa␈αfunction␈αto␈αbe␈αapplied␈α
to
␈↓ ↓N␈↓possibility,␈α
other␈α
notations␈α
are␈α
equally␈α
possible,␈↓ π∞␈↓the␈α≡elements␈α∨of␈α≡a␈α≡list␈α∨one␈α≡at␈α∨a␈α≡time
␈↓ ↓N␈↓such␈α_as␈α→the␈α_very␈α_widely␈α→known␈α_ALGOL               ␈↓ π∞␈↓(coordinate-wise␈α≡operation)␈α∨while␈α≡APPLY
␈↓ ↓N␈↓notation.␈α∂ In␈α∂fact,␈α∂an␈α∂ALGOL␈α∂front-end␈α∂has        ␈↓ π∞␈↓permits␈α∀an␈α∀operation␈α∀such␈α∀as␈α∀PLUS␈α∀to␈α∀be
␈↓ ↓N␈↓been␈α∪built␈α∩for␈α∪LISP␈α∩along␈α∪the␈α∩lines␈α∪of␈α∩the          ␈↓ π∞␈↓applied␈α∂to␈α∞all␈α∂the␈α∞elements␈α∂of␈α∞the␈α∂list␈α∞(APL's
␈↓ ↓N␈↓CGOL␈α∃front-end␈α∃(but␈α∃with␈α∃more␈α∃attention          ␈↓ π∞␈↓notion␈α⊃of␈α⊃reduction,␈α⊂written␈α⊃+/a).␈α⊃ APL,␈α⊂like
␈↓ ↓N␈↓paid␈α∂to␈α∂preserving␈α∂the␈α∂semantics␈α∂of␈α∞ALGOL         ␈↓ π∞␈↓LISP,␈α∂o␈↓↓␈↓β@␈↓↓␈↓ers␈α∂non-applicative␈α∂features␈α⊂such␈α∂as
␈↓ ↓N␈↓than␈α↔is␈α↔implicit␈α⊗in␈α↔our␈α↔translation␈α↔of␈α⊗the         ␈↓ π∞␈↓assignment␈αand␈αgoto,␈αbut␈αits␈αusers␈αare␈αstrongly
␈↓ ↓N␈↓ALGOL␈α
example␈α
above),␈α
and␈α
if␈α
the␈α
question         ␈↓ π∞␈↓encouraged␈α∞to␈α∞rely␈α∞on␈α∞the␈α∞applicative␈α∂part␈α∞of
␈↓ ↓N␈↓of␈α∀whether␈α∪the␈α∀notation␈α∪was␈α∀widely␈α∪known          ␈↓ π∞␈↓APL,␈α∀and␈α∀(presumably)␈α∪to␈α∀ensure␈α∀that␈α∪this
␈↓ ↓N␈↓became␈α∃a␈α∃serious␈α∃issue,␈α∃the␈α∃replacement␈α∀of        ␈↓ π∞␈↓happens␈αAPL␈αo␈↓↓␈↓β@␈↓↓␈↓ers␈αa␈αbare␈αminimum␈αof␈αnon-
␈↓ ↓N␈↓CGOL␈α∞or␈α∞MACSYMA␈α∞notation␈α∂by␈α∞ALGOL                ␈↓ π∞␈↓applicative␈α⊗control␈α⊗structures.␈α⊗ A␈α∃signi␈↓↓␈↓βC␈↓↓␈↓cant
␈↓ ↓N␈↓notation␈α∪is␈α∩straightforward,␈α∪modulo␈α∩tortuous    ␈↓ π∞␈↓bene␈↓↓␈↓βC␈↓↓␈↓t␈α∩of␈α∩this␈α∪style␈α∩is␈α∩that␈α∪reasoning␈α∩about
␈↓ ↓N␈↓implementation␈α≠when␈α~the␈α≠(rarely␈α≠used␈α~in          ␈↓ π∞␈↓such␈α↔programs␈α_can␈α↔be␈α_done␈α↔in␈α_the␈α↔same
␈↓ ↓N␈↓practice)␈α∪environment-handling␈α∪capability␈α∩of   ␈↓ π∞␈↓algebraic␈α∃formalism␈α∃that␈α∀we␈α∃have␈α∃all␈α∀been
␈↓ ↓N␈↓ALGOL␈α∂is␈α∞given␈α∂full␈α∞throttle.␈α∂ Our␈α∞personal       ␈↓ π∞␈↓raised␈α∪on␈α∪since␈α∪birth,␈α∪instead␈α∪of␈α∀having␈α∪to
␈↓ ↓N␈↓feeling␈α∞is␈α∞that␈α∞the␈α∞CGOL␈α∞notation␈α∂is␈α∞already       ␈↓ π∞␈↓invent␈α
systems␈α
of␈α
logic␈α
especially␈α
to␈α
cope␈αwith
␈↓ ↓N␈↓so␈αclose␈αto␈αALGOL␈αnotation␈αwhen␈αit␈αcomes␈αto         ␈↓ π∞␈↓the␈α&non-algebraic␈α&control␈α&structures␈α&of
␈↓ ↓N␈↓those␈α∀things␈α∀one␈α∀regularly␈α∀wants␈α∀to␈α∃say␈α∀in         ␈↓ π∞␈↓conventional␈α≠programming␈α≤languages.␈α≠ For
␈↓ ↓N␈↓ALGOL␈α≠that␈α≤to␈α≠insist␈α≤on␈α≠one-hundred-             ␈↓ π∞␈↓example,␈α⊃knowing␈α⊃that␈α⊃+␈α⊃is␈α⊃associative␈α⊂even
␈↓ ↓N␈↓percent␈α∩ALGOL␈α∩notation␈α⊃is␈α∩gilding␈α∩the␈α⊃lily        ␈↓ π∞␈↓when␈α≤applied␈α≤to␈α≤equal-length␈α≤vectors␈α≤as
␈↓ ↓N␈↓for almost all applications.                ␈↓ π∞␈↓opposed␈α∀to␈α∀scalars,␈α∀we␈α∀can␈α∀immediately␈α∪see
                                            ␈↓ π∞␈↓that␈α∃(u+v)+w␈α∃computes␈α∃the␈α∃same␈α∃vector␈α∀as
␈↓ ↓N␈↓LISP's␈α⊗independence␈α⊗of␈α⊗choice␈α↔of␈α⊗notation        ␈↓ π∞␈↓u+(v+w),␈αwhereas␈αwe␈αmay␈αhave␈αto␈αargue␈αmore
␈↓ ↓N␈↓may␈α%be␈α&of␈α%value␈α%in␈α&an␈α%educational                 ␈↓ π∞␈↓indirectly␈α
about␈αthe␈α
e␈↓↓␈↓β@␈↓↓␈↓ect␈α
of␈αthe␈α
corresponding
␈↓ ↓N␈↓environment␈α
where,␈αalthough␈α
a␈αcommitment␈α
to      ␈↓ π∞␈↓two␈α∪programs␈α∪in␈α∪a␈α∪non-applicative␈α∀(in␈α∪this
␈↓ ↓N␈↓a␈α↔single␈α⊗language␈α↔may␈α⊗have␈α↔already␈α⊗been           ␈↓ π∞␈↓case␈α2non-vector-manipulating)␈α2language.
␈↓ ↓N␈↓made,␈α∞individual␈α∞instructors␈α∞may␈α∞nevertheless   ␈↓ π∞␈↓Vector␈α∃spaces␈α⊗have␈α∃been␈α∃well␈α⊗studied␈α∃and
␈↓ ↓N␈↓have␈α⊃a␈α⊃requirement␈α⊃for␈α⊃a␈α⊃di␈↓↓␈↓β@␈↓↓␈↓erent␈α⊂notation.       ␈↓ π∞␈↓their␈α
properties␈α
carry␈α
over␈α
readily␈αto␈α
reasoning
␈↓ ↓N␈↓LISP's␈α%ability␈α%to␈α%change␈α%notations␈α%in            ␈↓ π∞␈↓about APL programs.
␈↓ ↓N␈↓midstream␈α+without␈α+having␈α+to␈α*change
␈↓ ↓N␈↓languages␈α→reduces␈α→the␈α→overhead␈α→associated       ␈↓ π∞␈↓Let␈αus␈α
give␈αsome␈α
examples␈αwhere␈α
LISP␈αcan␈α
be
␈↓ ↓N␈↓with␈αmaintaining␈αseveral␈αentire␈αlanguages␈αand    ␈↓ π∞␈↓used␈αas␈α
an␈αapplicative␈αlanguage.␈α
 The␈αCGOL
␈↓ ↓N␈↓their␈αsupporting␈αmaintenance␈αteams␈αand␈αother     ␈↓ π∞␈↓notation␈α∂a[[b]]␈α∂for␈α∂(MAPCAR␈α∂'a␈α∂b)␈α∂helps␈α∞to
␈↓ ↓N␈↓paraphernalia.␈α⊗ For␈α∃example,␈α⊗if␈α⊗APL␈α∃were         ␈↓ π∞␈↓emphasize␈α1the␈α1functional␈α1nature␈α1of
␈↓ ↓N␈↓needed␈α
on␈αoccasion,␈α
it␈αwould␈α
not␈αbe␈α
impossible     ␈↓ π∞␈↓MAPCAR,␈α~inasmuch␈α~as␈α~a[[[b0,␈α~b1,␈α→b2]]]
␈↓ ↓N␈↓to␈α∂embed␈α∂it␈α∂in␈α∂LISP;␈α∂indeed␈α∂a␈α⊂very␈α∂compact          ␈↓ π∞␈↓(where␈α∞[b0,␈α∂b1,␈α∞b2]␈α∞is␈α∂the␈α∞list␈α∂being␈α∞operated
␈↓ ↓N␈↓de␈↓↓␈↓βC␈↓↓␈↓nition␈α≥of␈α≡APL␈α≥is␈α≥possible␈α≡in␈α≥LISP.             ␈↓ π∞␈↓on)␈αmeans␈αsimply␈αthe␈αlist␈α[a(b0),␈αa(b1),␈αa(b2)]␈α.
␈↓ ↓N␈↓However␈α⊂it␈α⊂would␈α⊂seem␈α⊂only␈α⊂fair␈α⊂to␈α⊂ask␈α⊂the          ␈↓ π∞␈↓(The␈α↔reason␈α⊗for␈α↔two␈α⊗brackets␈α↔is␈α↔that␈α⊗two
␈↓ ↓N␈↓users of such                               ␈↓ π∞␈↓separate␈α→operations␈α→are␈α→really␈α→invoked␈α→by
                                            ␈↓ π∞␈↓a[[b]],␈α
which␈α∞is␈α
equivalent␈α
to␈α∞a[x]␈α
where␈α∞x␈α
is
                                            ␈↓ π∞␈↓[b]␈α⊂(the␈α∂list␈α⊂whose␈α⊂only␈α∂element␈α⊂is␈α⊂b).␈α∂ Thus
␈↓ ↓N␈↓7.␈α LISP␈αis␈αapplicative.␈α That␈αis,␈αone␈αcan␈αwrite    ␈↓ π∞␈↓when␈αu␈αand␈αv␈αare␈αadded␈αcoordinatewise␈αusing
␈↓ ↓N␈↓non-trivial␈α~programs␈α→in␈α~LISP␈α~using␈α→only          ␈↓ π∞␈↓plus[[u,v]],␈α∃in␈α∃fact␈α∀the␈α∃operation␈α∃is␈α∀plus[x]
␈↓ ↓N␈↓functional␈α
application␈α
that␈α
in␈α
other␈α
languages   ␈↓ π∞␈↓where␈αx␈α
is␈αthe␈α
two-element␈αlist␈α[u,v].)␈α
Likewise
␈↓ ↓N␈↓would␈α≤have␈α≤to␈α≤be␈α≤written␈α≤iteratively␈α≤or           ␈↓ π∞␈↓the␈α#notation␈α#a{b}␈α#for␈α#(APPLY␈α#'a␈α"b)
␈↓ ↓N␈↓recursively.␈α∞ The␈α∞two␈α∞LISP␈α∞functions␈α∞(strictly,  ␈↓ π∞␈↓emphasizes␈αthat␈α
a␈αis␈αjust␈α
being␈αapplied␈α
to␈αthe
␈↓ ↓N␈↓functionals␈α∪or␈α∩combinators)␈α∪that␈α∪supply␈α∩this     ␈↓ π∞␈↓list␈α⊃of␈α⊃arguments␈α⊃b.␈α⊃Thus␈α⊃given␈α⊃a␈α⊃list␈α∩b␈α⊃of
␈↓ ↓N␈↓power␈α/are␈α/MAPCAR␈α/and␈α/APPLY.                     ␈↓ π∞␈↓numbers,␈αplus{b}␈αyields␈αits␈αsum,␈αcorresponding
␈↓ ↓N␈↓αLISP Brief␈↓ `9


␈↓ ↓N␈↓to␈α∪+/b␈α∀in␈α∪APL.␈α∪ Given␈α∀two␈α∪lists␈α∪a␈α∀and␈α∪b,             ␈↓ π∞␈↓specify␈α⊃to␈α⊂APL␈α⊃whether␈α⊃or␈α⊂not␈α⊃he␈α⊃wants␈α⊂to
␈↓ ↓N␈↓plus[[a,b]]␈α yields␈α the␈α∨list␈α which␈α is␈α∨the          ␈↓ π∞␈↓apply␈α
his␈α∞operation␈α
to␈α
the␈α∞list␈α
as␈α
an␈α∞entity␈α
or
␈↓ ↓N␈↓coordinate-wise␈α&sum␈α&of␈α&the␈α&two␈α%lists,            ␈↓ π∞␈↓coordinatewise␈α∪to␈α∪its␈α∪individual␈α∪components.
␈↓ ↓N␈↓corresponding␈α_to␈α_APL's␈α_(syntactically␈α↔more      ␈↓ π∞␈↓In␈α#LISP␈α#one␈α#distinguishes␈α#these␈α#cases
␈↓ ↓N␈↓succinct␈α∞but␈α
no␈α∞more␈α
or␈α∞less␈α∞applicative)␈α
a+b.     ␈↓ π∞␈↓explicitly as a(b) versus a[[b]].
␈↓ ↓N␈↓Thus␈α∪to␈α∩compute␈α∪the␈α∩inner␈α∪product␈α∪of␈α∩two
␈↓ ↓N␈↓vectors␈α∨(represented␈α as␈α∨lists␈α though␈α∨the
␈↓ ↓N␈↓semantics␈α∞of␈α∞LISP␈α
does␈α∞not␈α∞forbid␈α∞lists␈α
being      ␈↓ π∞␈↓8.␈α∩ LISP␈α∩is␈α∩widely␈α∩used␈α∩in␈α∩academia.␈α∩ In␈α∩a
␈↓ ↓N␈↓represented␈α'internally␈α'as␈α'vectors␈α&when          ␈↓ π∞␈↓large␈α≠portion␈α~of␈α≠the␈α≠academic␈α~computing
␈↓ ↓N␈↓appropriate)␈α?it␈α?su␈↓↓␈↓β@␈↓↓␈↓ices␈α?to␈α>write                ␈↓ π∞␈↓community␈α∂LISP␈α∞is␈α∂either␈α∞a␈α∂␈↓↓␈↓βC␈↓↓␈↓rst␈α∞or␈α∂a␈α∞second
␈↓ ↓N␈↓plus{times[[a,b]]},␈α corresponding␈α!to␈α APL's     ␈↓ π∞␈↓language.␈α⊂ I␈α⊂received␈α⊂last␈α⊂week␈α⊂a␈α⊃letter␈α⊂from
␈↓ ↓N␈↓+/a*b.␈α⊂ One␈α⊃way␈α⊂to␈α⊃write␈α⊂a␈α⊃one-line␈α⊂matrix         ␈↓ π∞␈↓Gene␈α∪Freuder,␈α∪a␈α∪recent␈α∪MIT␈α∪graduate␈α∩now
␈↓ ↓N␈↓multiplication␈α∞routine␈α∞in␈α∞LISP␈α∞(yes,␈α∞APL␈α
has      ␈↓ π∞␈↓teaching␈α∃at␈α∃Indiana,␈α∀where␈α∃he␈α∃is␈α∃their␈α∀AI
␈↓ ↓N␈↓no monopoly on one-liners) would be         ␈↓ π∞␈↓representative.␈α⊂ He␈α∂was␈α⊂happy␈α∂to␈α⊂report␈α∂that
␈↓ ↓N␈↓  for␈α⊗i␈α⊗in␈α⊗x␈α⊗collect␈α⊗for␈α⊗j␈α⊗in␈α⊗list[y]␈α⊗collect        ␈↓ π∞␈↓in␈αhis␈αdepartment␈α"everyone␈αspeaks␈αLISP␈αas␈αa
␈↓ ↓N␈↓␈↓ α∞plus{times[[x,y]]} .                        ␈↓ π∞␈↓mother␈α_tongue."␈α_While␈α_one␈α_might␈α_not␈α_be
␈↓ ↓N␈↓(Here␈α↔list[y]␈α↔transposes␈α_the␈α↔list␈α↔of␈α_lists␈α↔y,      ␈↓ π∞␈↓surprised␈α∃to␈α∃hear␈α∃this␈α∃about␈α∃a␈α∃department
␈↓ ↓N␈↓representing␈α
a␈α
matrix␈α
stored␈α
as␈α
a␈α
list␈α
of␈αrows,     ␈↓ π∞␈↓with␈αa␈αheavy␈αAI␈αbias,␈αit␈αis␈αa␈αtribute␈αto␈αLISP's
␈↓ ↓N␈↓for␈α∀reasons␈α∪about␈α∀as␈α∪obscure␈α∀as␈α∀those␈α∪that         ␈↓ π∞␈↓ubiquity␈α∩that␈α⊃it␈α∩should␈α⊃be␈α∩so␈α⊃honored␈α∩in␈α⊃a
␈↓ ↓N␈↓account␈αfor␈αa␈αvariety␈αof␈αAPL␈α
techniques␈αsuch       ␈↓ π∞␈↓department␈α∩noted␈α∩primarily␈α∩for␈α∩its␈α∩work␈α∩on
␈↓ ↓N␈↓as␈αconditional␈αgoto.␈α The␈αreader␈αwho␈αfollowed     ␈↓ π∞␈↓programming␈α⊃languages␈α∩and␈α⊃multiple-valued
␈↓ ↓N␈↓our␈α∞explanation␈α∞earlier␈α∂of␈α∞what␈α∞a[b]␈α∂did␈α∞will      ␈↓ π∞␈↓logic.
␈↓ ↓N␈↓realize␈α-that␈α-list[y]␈α-is␈α-equivalent␈α,to
␈↓ ↓N␈↓list[[y0,y1,...]]␈α↔where␈α↔y␈α↔=␈α↔[y0,y1,...].)␈α↔In␈α↔this
␈↓ ↓N␈↓example␈α≠I␈α≠have␈α≠deliberately␈α≤avoided␈α≠the          ␈↓ π∞␈↓9.␈α∂ LISP␈α∞is␈α∂used␈α∞by␈α∂half␈α∞the␈α∂MIT␈α∞Computer
␈↓ ↓N␈↓equivalent␈α∂more␈α⊂succinct␈α∂but␈α⊂less␈α∂transparent    ␈↓ π∞␈↓Science␈α⊂faculty.␈α⊃ Thus␈α⊂choosing␈α⊂LISP␈α⊃as␈α⊂the
␈↓ ↓N␈↓syntactic variant of the above,             ␈↓ π∞␈↓main␈α∂departmental␈α∞language,␈α∂if␈α∂one␈α∞language
␈↓ ↓N␈↓  (\i;(\j;plus{times[[i,j]]})[[list[y]]])[[x]]␈↓ π∞␈↓is␈α∪to␈α∪be␈α∪chosen␈α∪ueber␈α∪alles,␈α∪would␈α∪seem␈α∪to
␈↓ ↓N␈↓This␈αis␈α
an␈αexample␈α
of␈αwhere␈αLISP's␈α
versatility     ␈↓ π∞␈↓involve␈αthe␈αleast␈αupheaval.␈αFurther,␈αLISP␈αas␈α
a
␈↓ ↓N␈↓permits␈α∩the␈α⊃user␈α∩to␈α⊃avoid␈α∩the␈α⊃APL␈α∩trap␈α⊃of           ␈↓ π∞␈↓high␈α∃quality␈α∀language␈α∃attracts␈α∃high␈α∀quality
␈↓ ↓N␈↓being␈α∂forced␈α∂to␈α∂write␈α∂code␈α∂applicatively␈α∞even     ␈↓ π∞␈↓maintenance␈α"personnel.␈α" LISP␈α"has␈α"been
␈↓ ↓N␈↓when␈αit␈αmight␈αbe␈αbetter␈αunderstood␈αby␈αwriting      ␈↓ π∞␈↓maintained␈α
here␈α∞not␈α
only␈α
by␈α∞Jon␈α
L.␈α∞White,␈α
a
␈↓ ↓N␈↓it␈α∃dynamically␈α∀using␈α∃a␈α∀"for"␈α∃loop.␈α∀ (Strictly     ␈↓ π∞␈↓very␈α∩experienced␈α∩LISP␈α∪systems␈α∩programmer,
␈↓ ↓N␈↓speaking,␈α
the␈α
APL␈α
user␈α
does␈α
have␈α
the␈α
option        ␈↓ π∞␈↓but␈αby␈αsome␈αof␈αthe␈αsharpest␈αgraduate␈αstudents
␈↓ ↓N␈↓of␈α⊃a␈α⊃dynamic␈α⊃solution,␈α⊃as␈α⊃goto␈α⊃exists␈α⊃in␈α⊃the        ␈↓ π∞␈↓in␈α⊃the␈α⊃world.␈α∩ Guy␈α⊃L.␈α⊃Steele,␈α⊃winner␈α∩of␈α⊃the
␈↓ ↓N␈↓language;␈αhowever␈α
there␈αare␈αdynamic␈α
solutions    ␈↓ π∞␈↓1975␈α-George␈α-Forsythe␈α-student␈α,paper
␈↓ ↓N␈↓and␈α
dynamic␈α∞solutions,␈α
and␈α
code␈α∞written␈α
with      ␈↓ π∞␈↓competition␈α![9],␈α!the␈α!main␈α!student-paper
␈↓ ↓N␈↓goto's␈α∞rarely␈α∂constitutes␈α∞an␈α∂improvement␈α∞over    ␈↓ π∞␈↓competition␈α
in␈α
the␈α
computer-science␈α
world,␈α
has
␈↓ ↓N␈↓other arcane solutions to programming tasks.)␈↓ π∞␈↓been␈α⊗a␈α⊗shining␈α∃example␈α⊗of␈α⊗such␈α⊗help␈α∃for
                                            ␈↓ π∞␈↓several␈α
years␈α
dating␈α
back␈α
to␈αhis␈α
undergraduate
␈↓ ↓N␈↓In␈α∂some␈α⊂respects␈α∂LISP's␈α∂applicative␈α⊂ability␈α∂is    ␈↓ π∞␈↓days.␈α⊂ The␈α⊂situation␈α∂seems␈α⊂simply␈α⊂to␈α⊂be␈α∂that
␈↓ ↓N␈↓superior␈α→to␈α→APL's.␈α→ APL␈α→lacks␈α~a␈α→speci␈↓↓␈↓βC␈↓↓␈↓c           ␈↓ π∞␈↓the␈α∪best␈α∩languages␈α∪attract␈α∩the␈α∪best␈α∩students.
␈↓ ↓N␈↓operator␈α3that␈α3permits␈α2coordinate-wise          ␈↓ π∞␈↓Unless␈α
MIT␈αsuddenly␈α
experiences␈αa␈α
dearth␈αof
␈↓ ↓N␈↓application␈α∪of␈α∪a␈α∪scalar␈α∪operator,␈α∀but␈α∪rather      ␈↓ π∞␈↓good␈α∞students,␈α∞a␈α∞fate␈α∂few␈α∞of␈α∞us␈α∞want␈α∂even␈α∞to
␈↓ ↓N␈↓relies␈α∩on␈α∩the␈α∩fact␈α⊃that␈α∩a␈α∩scalar␈α∩operation␈α⊃is       ␈↓ π∞␈↓contemplate,␈α↔this␈α↔high␈α_quality␈α↔maintenance
␈↓ ↓N␈↓being␈α↔applied␈α↔to␈α↔a␈α↔vector␈α↔to␈α↔deduce␈α⊗that           ␈↓ π∞␈↓should␈αcontinue␈α
at␈αor␈α
near␈αits␈αpresent␈α
enviably
␈↓ ↓N␈↓coordinate-wise␈αoperation␈αis␈αcalled␈αfor.␈α When   ␈↓ π∞␈↓high level.
␈↓ ↓N␈↓a␈α⊂user␈α∂has␈α⊂de␈↓↓␈↓βC␈↓↓␈↓ned␈α∂an␈α⊂operation␈α⊂that␈α∂applies
␈↓ ↓N␈↓equally␈α∞well␈α∞to␈α∞scalars␈α∞and␈α∞vectors,␈α∞he␈α∞cannot
␈↓ ↓N␈↓αLISP Brief␈↓ T10


␈↓ ↓N␈↓10.␈α⊂ No␈α⊂other␈α⊂language␈α⊂enjoys␈α⊂all␈α⊂the␈α⊂above        ␈↓ π∞␈↓ALGOL-like␈αlanguage␈αrevealed␈αa␈αserious␈αlack
␈↓ ↓N␈↓advantages␈α∞of␈α
LISP.␈α∞ This␈α
remains␈α∞true␈α
even       ␈↓ π∞␈↓of␈αversatility␈αin␈αALGOL.␈α Actually,␈αALGOL's
␈↓ ↓N␈↓if␈α∩advantages␈α∩2␈α∩and␈α∩4␈α∩are␈α∩omitted.␈α∩ Let␈α⊃us          ␈↓ π∞␈↓control␈α↔structures␈α↔are␈α↔remarkably␈α⊗powerful;
␈↓ ↓N␈↓argue␈α⊃this␈α⊃point␈α⊃on␈α∩a␈α⊃language-by-language       ␈↓ π∞␈↓one␈α_can␈α_do␈α_truly␈α_astonishing␈α→things␈α_with
␈↓ ↓N␈↓basis,␈α∩choosing␈α∩(at␈α∪the␈α∩risk␈α∩of␈α∪o␈↓↓␈↓β@␈↓↓␈↓ending␈α∩all       ␈↓ π∞␈↓ALGOL's␈α
goto␈αstatement,␈α
such␈α
as␈αjumping␈α
out
␈↓ ↓N␈↓whose␈α,languages␈α,have␈α,been␈α,omitted)              ␈↓ π∞␈↓of␈α∃a␈α∃procedure␈α∃body␈α∃that␈α∃has␈α∃called␈α∃itself
␈↓ ↓N␈↓FORTRAN,␈α⊂COBOL,␈α⊂ALGOL,␈α⊂PL/I,␈α⊂APL,               ␈↓ π∞␈↓recursively␈α→to␈α→a␈α→great␈α→depth,␈α→resulting␈α→in
␈↓ ↓N␈↓ALGOL␈α∞68␈α∞and␈α∞PASCAL.␈α∞ In␈α∂the␈α∞following            ␈↓ π∞␈↓exiting␈α⊃from␈α⊃all␈α⊃those␈α⊃levels␈α⊃of␈α∩recursion␈α⊃in
␈↓ ↓N␈↓we␈αomit␈αreference␈αto␈αitems␈α2,␈α4,␈αand␈α9;␈αthe␈α␈↓↓␈↓βC␈↓↓␈↓rst      ␈↓ π∞␈↓response␈α
to␈α
one␈α␈↓αgoto␈↓.␈α
 Also␈α
ALGOL␈αo␈↓α␈↓β@␈↓α␈↓ers␈α
call
␈↓ ↓N␈↓two␈α_are␈α_easy␈α→to␈α_satisfy␈α_while␈α_the␈α→last␈α_is           ␈↓ π∞␈↓by␈αname,␈αwhich␈αpermits␈αsuch␈αuseful␈αconstructs
␈↓ ↓N␈↓obviously impossible.                       ␈↓ π∞␈↓as␈α"Jensen's␈α"device␈α"for␈α"implementing␈α"a
                                            ␈↓ π∞␈↓summation␈α!operator.␈α! Unfortunately␈α these
␈↓ ↓N␈↓FORTRAN:␈αThis␈αfails␈αon␈αitems␈α1,␈α5,␈α6␈αand␈α7.          ␈↓ π∞␈↓strengths␈α∞of␈α∞ALGOL␈α∞do␈α∞not␈α∞make␈α∞up␈α∞for␈α
its
␈↓ ↓N␈↓FORTRAN's␈α⊂storage␈α⊂allocation␈α⊂facilities␈α⊂and     ␈↓ π∞␈↓weakness␈α⊃in␈α⊃the␈α⊃versatility␈α⊃of␈α⊃its␈α⊃data␈α⊂types.
␈↓ ↓N␈↓control␈α
primitives␈α
are␈α
too␈α
rudimentary␈α
to␈α
make    ␈↓ π∞␈↓ALGOL␈αfails␈αon␈αitems␈α1,␈α
3␈α(to␈αa␈αsmall␈αbut␈α
not
␈↓ ↓N␈↓FORTRAN␈α_useful␈α↔outside␈α_the␈α_domain␈α↔of             ␈↓ π∞␈↓terribly important extent), 5, 6, and 7.
␈↓ ↓N␈↓numerical␈α⊂arrays,␈α⊂for␈α⊂which␈α⊂it␈α⊃was␈α⊂designed.
␈↓ ↓N␈↓By␈α~bending␈α→over␈α~backwards␈α→one␈α~can␈α→do              ␈↓ π∞␈↓PL/I.␈α∪ PL/I␈α∪is␈α∪nothing␈α∪if␈α∪not␈α∪versatile.␈α∪ At
␈↓ ↓N␈↓anything␈α∞in␈α∂FORTRAN,␈α∞as␈α∞in␈α∂any␈α∞universal          ␈↓ π∞␈↓least␈α
that␈α
is␈α
what␈α
IBM␈α
had␈α
in␈α
mind␈α
when␈α
they
␈↓ ↓N␈↓language␈α→(in␈α_Turing's␈α→sense);␈α→for␈α_example        ␈↓ π∞␈↓designed␈α∞it.␈α
 However,␈α∞to␈α
be␈α∞versatile␈α
without
␈↓ ↓N␈↓Joseph␈αWeizenbaum␈αimplemented␈αSLIP,␈αa␈αlist       ␈↓ π∞␈↓being␈αmodular␈αis␈αto␈αbe␈αa␈αsuper-market,␈αwhere
␈↓ ↓N␈↓processing␈α
language,␈α
in␈α
FORTRAN,␈α
and␈α
it␈αis        ␈↓ π∞␈↓sometimes␈α∩you␈α∩spend␈α⊃more␈α∩time␈α∩looking␈α⊃for
␈↓ ↓N␈↓the␈αlanguage␈αused␈αfor␈αsymbol␈αmanipulation␈αat      ␈↓ π∞␈↓the␈α≡aisle␈α≡you␈α≡need␈α≡than␈α≡all␈α≡the␈α≥other
␈↓ ↓N␈↓Bell␈αLaboratories.␈α However,␈αone␈αis␈α
su␈↓↓␈↓β@␈↓↓␈↓iciently  ␈↓ π∞␈↓operations␈αcombined.␈α PL/I␈α
fails␈αon␈αitems␈α
5,␈α6
␈↓ ↓N␈↓hemmed␈α&in␈α'by␈α&petty␈α'restrictions␈α&and              ␈↓ π∞␈↓and 7, as well as 1 in my opinion.
␈↓ ↓N␈↓inadequate␈αdata␈αand␈αcontrol␈αstructures␈αthat␈αno
␈↓ ↓N␈↓very strong case can be made for it.        ␈↓ π∞␈↓APL.␈α∨ APL␈α≡passes␈α∨strongly␈α≡on␈α∨item␈α≡7
                                            ␈↓ π∞␈↓(applicative),␈α
though␈αnot␈α
without␈α
a␈αblack␈α
mark
␈↓ ↓N␈↓COBOL.␈α∃ COBOL␈α∀has␈α∃something␈α∃to␈α∀o␈↓↓␈↓β@␈↓↓␈↓er              ␈↓ π∞␈↓for␈α⊗being␈α↔unable␈α⊗to␈α⊗distinguish␈α↔a(b)␈α⊗from
␈↓ ↓N␈↓academia␈αthat␈αFORTRAN␈α
lacks,␈αand␈αthat␈αis␈α
a         ␈↓ π∞␈↓a[[b]]␈α∩(using␈α∩CGOL␈α∩notation).␈α∩ For␈α∪what␈α∩it
␈↓ ↓N␈↓"data␈α∂division"␈α∂(to␈α∂use␈α⊂COBOL␈α∂terminology)       ␈↓ π∞␈↓attempts␈α∞to␈α∞be,␈α∞namely␈α∂a␈α∞vector-manipulating
␈↓ ↓N␈↓that␈α∞permits␈α∂the␈α∞user␈α∞to␈α∂de␈↓↓␈↓βC␈↓↓␈↓ne␈α∞a␈α∂rich␈α∞variety       ␈↓ π∞␈↓language,␈αit␈αalso␈αdoes␈αwell␈αon␈αitem␈α1.␈α Though
␈↓ ↓N␈↓of␈α∂data␈α∂types.␈α∂ This␈α∂can␈α∂lead␈α∂to␈α∂considerable      ␈↓ π∞␈↓we␈α_promised␈α↔to␈α_omit␈α↔reference␈α_to␈α_item␈α↔4
␈↓ ↓N␈↓simpli␈↓↓␈↓βC␈↓↓␈↓cation␈α∞of␈α
the␈α∞"program␈α∞division,"␈α
since   ␈↓ π∞␈↓(interactive),␈α⊃this␈α⊂is␈α⊃a␈α⊂very␈α⊃strong␈α⊃feature␈α⊂of
␈↓ ↓N␈↓the␈αCOBOL␈αcompiler␈αcan␈αautomatically␈αmake        ␈↓ π∞␈↓APL,␈αand␈αsupplied␈αme␈αwith␈αmy␈αone␈αreason␈αto
␈↓ ↓N␈↓many␈αdecisions␈αabout␈αwhere␈αto␈αput␈αthings␈αand       ␈↓ π∞␈↓use␈α∞APL␈α∞considerably␈α∞during␈α∞a␈α∂summer␈α∞visit
␈↓ ↓N␈↓how␈α&to␈α&represent␈α&them.␈α& Unfortunately           ␈↓ π∞␈↓to␈α↔IBM.␈α⊗ Unfortunately,␈α↔little␈α⊗of␈α↔my␈α⊗work
␈↓ ↓N␈↓COBOL's␈α∩data␈α∩types␈α∩are␈α∩rich␈α∩in␈α∩about␈α⊃the           ␈↓ π∞␈↓happened␈α∀to␈α∀␈↓α␈↓βC␈↓α␈↓t␈α∀the␈α∀vector␈α∀mold␈α∀very␈α∪well,
␈↓ ↓N␈↓same␈αsense␈αthat␈α
an␈αEskimo␈α␈↓↓␈↓βC␈↓↓␈↓nds␈αa␈α
richness␈αof        ␈↓ π∞␈↓despite␈α⊃the␈α⊃fact␈α⊃that␈α⊃most␈α⊃of␈α⊃it␈α∩was␈α⊃heavily
␈↓ ↓N␈↓snow␈αvarieties␈αin␈αthe␈αArctic;␈αthis␈αrichness␈αgoes   ␈↓ π∞␈↓numerical,␈α⊃and␈α⊂I␈α⊃found␈α⊂myself␈α⊃from␈α⊃time␈α⊂to
␈↓ ↓N␈↓unappreciated␈α,in␈α,other␈α,climates,␈α,and            ␈↓ π∞␈↓time␈α∪using␈α∀the␈α∪embryonic␈α∪360␈α∀LISP␈α∪system
␈↓ ↓N␈↓COBOL's␈α(concern␈α'with␈α(business␈α'data              ␈↓ π∞␈↓maintained␈α∀by␈α∀Fred␈α∃Blair␈α∀at␈α∀IBM,␈α∃on␈α∀the
␈↓ ↓N␈↓processing␈α∀makes␈α∃it␈α∀too␈α∃narrow␈α∀for␈α∃use␈α∀in          ␈↓ π∞␈↓ground␈α⊗that␈α⊗the␈α⊗additional␈α⊗time␈α⊗I␈α⊗had␈α∃to
␈↓ ↓N␈↓other␈α"environments.␈α# We␈α"can␈α#rule␈α"out             ␈↓ π∞␈↓spend␈α∪running␈α∪back␈α∩and␈α∪forth␈α∪between␈α∩the
␈↓ ↓N␈↓COBOL␈α
on␈αthe␈α
same␈α
grounds␈αas␈α
FORTRAN,             ␈↓ π∞␈↓CP/CMS␈α∂editor␈α⊂and␈α∂LISP␈α⊂was␈α∂made␈α⊂up␈α∂for
␈↓ ↓N␈↓together with item 8.                       ␈↓ π∞␈↓by␈α∀the␈α∀considerably␈α∀decreased␈α∪programming
                                            ␈↓ π∞␈↓time␈α
in␈α
LISP.␈α
 Thus␈α
I␈α
would␈α
fail␈α
APL␈αon␈α
item
␈↓ ↓N␈↓ALGOL.␈α⊗ A␈α∃discussion␈α⊗earlier␈α∃(item␈α⊗6)␈α∃of          ␈↓ π∞␈↓1,␈α→though␈α→not␈α→as␈α→seriously␈α→as␈α→the␈α→above
␈↓ ↓N␈↓LISP's␈α!ability␈α!to␈α!disguise␈α!itself␈α!as␈α an           ␈↓ π∞␈↓languages.␈α∀ What␈α∃really␈α∀makes␈α∃APL␈α∀totally
␈↓ ↓N␈↓αLISP Brief␈↓ V11


␈↓ ↓N␈↓unacceptable␈α⊂is␈α⊂the␈α⊂insistence␈α⊂on␈α⊃a␈α⊂character     ␈↓ π∞␈↓B.  DRAWBACKS OF LISP.
␈↓ ↓N␈↓set␈α∂so␈α∞out␈α∂of␈α∞touch␈α∂with␈α∞the␈α∂ASCII␈α∞standard
␈↓ ↓N␈↓that␈α∞the␈α∞department␈α∂would␈α∞be␈α∞locked␈α∂into␈α∞an        ␈↓ π∞␈↓Most␈α∀of␈α∀the␈α∃complaints␈α∀of␈α∀this␈α∃section␈α∀are
␈↓ ↓N␈↓unacceptably␈α∂in␈↓α␈↓βD␈↓α␈↓exible␈α∂(not␈α∂to␈α∂say␈α∞expensive)    ␈↓ π∞␈↓implementation-speci␈↓α␈↓βC␈↓α␈↓c␈α∂and␈α∂do␈α∂not␈α⊂inhere␈α∂in
␈↓ ↓N␈↓situation␈α⊃if␈α⊃it␈α⊃were␈α⊃to␈α⊃generally␈α⊃adopt␈α⊂APL.       ␈↓ π∞␈↓the␈α⊗LISP␈α⊗language␈α⊗itself.␈α⊗ The␈α⊗one␈α⊗major
␈↓ ↓N␈↓APL also fails on 5 and 6.                  ␈↓ π∞␈↓exception␈α∂to␈α∂this␈α∂is␈α∂LISP's␈α∂typelessness.␈α⊂ It␈α∂is
                                            ␈↓ π∞␈↓unlikely␈α∞that␈α∂future␈α∞implementations␈α∂of␈α∞LISP
␈↓ ↓N␈↓ALGOL␈α∪68.␈α∪ This␈α∩language␈α∪is␈α∪full␈α∪of␈α∩nice           ␈↓ π∞␈↓will␈α∪clear␈α∪up␈α∪this␈α∪issue␈α∪without␈α∩introducing
␈↓ ↓N␈↓ideas.␈α
 It␈αhas␈α
been␈αcarefully␈α
thought␈α
about␈αby     ␈↓ π∞␈↓substantial␈α"incompatibilities␈α"with␈α!existing
␈↓ ↓N␈↓people␈α≠with␈α≠a␈α≠concern␈α≠for␈α≠elegance␈α≠and            ␈↓ π∞␈↓LISP␈α_software.␈α_ Moreover,␈α_many␈α_feel␈α↔that
␈↓ ↓N␈↓mathematical␈α≤precision.␈α≥ Unfortunately␈α≤the     ␈↓ π∞␈↓typelessness␈α_is␈α_more␈α_virtue␈α_than␈α→vice.␈α_ In
␈↓ ↓N␈↓former␈αhas␈αbeen␈αsacri␈↓α␈↓βC␈↓α␈↓ced␈αto␈αthe␈αlatter,␈αand␈αto     ␈↓ π∞␈↓contrast,␈α∀The␈α∃various␈α∀complaints␈α∃about␈α∀the
␈↓ ↓N␈↓learn␈α"ALGOL␈α"68␈α"requires␈α"considerable            ␈↓ π∞␈↓implementation␈α
cannot␈αbe␈α
taken␈αseriously␈α
from
␈↓ ↓N␈↓patience␈α:while␈α:one␈α:discovers␈α:the                ␈↓ π∞␈↓a␈α?␈αlong-term␈α?␈αstand-point.␈α?␈α Other
␈↓ ↓N␈↓correspondence␈α_between␈α_one's␈α_programming       ␈↓ π∞␈↓implementations␈α∂of␈α⊂LISP␈α∂are␈α∂presently␈α⊂in␈α∂an
␈↓ ↓N␈↓intuition␈α
and␈α
the␈α
picturesque␈α
vocabulary␈αof␈α
an    ␈↓ π∞␈↓experimental␈α
stage,␈α
one␈α
in␈α
hardware␈α(Richard
␈↓ ↓N␈↓ALGOL␈α∪68␈α∪programming␈α∪guide␈α∪(not␈α∪to␈α∪be             ␈↓ π∞␈↓Greenblatt's␈αLISP␈αmachine)␈αand␈αone␈αusing␈αthe
␈↓ ↓N␈↓confused␈αwith␈αthe␈αlanguage's␈αformal␈α
de␈↓α␈↓βC␈↓α␈↓nition,   ␈↓ π∞␈↓lexical␈α⊃scoping␈α∩of␈α⊃the␈α⊃lambda␈α∩calculus␈α⊃(Guy
␈↓ ↓N␈↓which␈α∪is␈α∪written␈α∪in␈α∪a␈α∪relatively␈α∪inaccessible     ␈↓ π∞␈↓Steele␈α0and␈α0Gerald␈α0Sussman).␈α/ Thus
␈↓ ↓N␈↓meta-language).␈α
 ALGOL␈α
68␈αfails␈α
on␈α
items␈α6,       ␈↓ π∞␈↓implementation-speci␈↓α␈↓βC␈↓α␈↓c␈αproperties␈αof␈αLISP␈αare
␈↓ ↓N␈↓7 and 8.                                    ␈↓ π∞␈↓at␈α
present␈α
in␈α
a␈α∞state␈α
of␈α
␈↓α␈↓βD␈↓α␈↓ux,␈α
and␈α∞taking␈α
them
                                            ␈↓ π∞␈↓into␈α≠account␈α≠in␈α~deciding␈α≠that␈α≠LISP␈α~was
␈↓ ↓N␈↓PASCAL.␈α⊂ Nicklaus␈α∂Wirth␈α⊂sensibly␈α∂designed       ␈↓ π∞␈↓inadequate␈α⊂would␈α∂be␈α⊂a␈α∂case␈α⊂of␈α⊂throwing␈α∂out
␈↓ ↓N␈↓PASCAL␈α∀to␈α∀be␈α∀simple␈α∀in␈α∀concept,␈α∃easy␈α∀to            ␈↓ π∞␈↓the␈α∀baby␈α∀with␈α∀the␈α∀bathwater.␈α∀ Let␈α∀us␈α∀now
␈↓ ↓N␈↓implement,␈α∩e␈↓α␈↓β@␈↓α␈↓icient,␈α∩yet␈α∩versatile␈α∩in␈α∩its␈α∩data    ␈↓ π∞␈↓begin␈α.with␈α.my␈α.one␈α.implementation-
␈↓ ↓N␈↓types.␈α∀Moreover,␈α∀he␈α∀saw␈α∪to␈α∀it␈α∀that␈α∀a␈α∪good           ␈↓ π∞␈↓independent complaint.
␈↓ ↓N␈↓implementation␈α∨on␈α∨a␈α machine␈α∨commonly
␈↓ ↓N␈↓found␈α∂in␈α∞universities␈α∂(a␈α∞large␈α∂CDC␈α∞machine)       ␈↓ π∞␈↓LISP␈α⊂does␈α⊂not␈α∂in␈α⊂any␈α⊂systematic␈α⊂way␈α∂permit
␈↓ ↓N␈↓was␈α∩made␈α∩available.␈α⊃ As␈α∩a␈α∩result,␈α⊃PASCAL          ␈↓ π∞␈↓the␈α∂user␈α∞to␈α∂specify␈α∞the␈α∂types␈α∞of␈α∂his␈α∂data␈α∞and
␈↓ ↓N␈↓has␈α∞attracted␈α∞the␈α∞attention␈α∞of␈α∂many␈α∞computer      ␈↓ π∞␈↓variables.␈α In␈αfact␈αsome␈αtypes␈αare␈αimplemented
␈↓ ↓N␈↓science␈α#departments␈α"as␈α#being␈α#an␈α"ideal            ␈↓ π∞␈↓directly␈α∀as␈α∀other␈α∀types␈α∀without␈α∀LISP␈α∀being
␈↓ ↓N␈↓pedagogical␈α language.␈α PASCAL's␈α∨greatest        ␈↓ π∞␈↓able␈α~to␈α→tell␈α~which␈α→type␈α~is␈α~intended.␈α→For
␈↓ ↓N␈↓drawback␈αis␈αthe␈αextent␈αto␈αwhich␈αWirth␈αhad␈αto        ␈↓ π∞␈↓example,␈α~NIL␈α→serves␈α~double␈α→duty␈α~as␈α→the
␈↓ ↓N␈↓compromise␈α
to␈αachieve␈α
ease␈αof␈α
implementation.    ␈↓ π∞␈↓boolean␈αFALSE␈αand␈α
the␈αempty␈αlist,␈αas␈α
well␈αas
␈↓ ↓N␈↓As␈α≠a␈α≤result,␈α≠PASCAL␈α≠(like␈α≤every␈α≠other             ␈↓ π∞␈↓being␈αrecognized␈αby␈αLISP␈αas␈αan␈αatom␈α(though
␈↓ ↓N␈↓language␈α↔above)␈α↔lacks␈α↔the␈α⊗␈↓α␈↓βC␈↓α␈↓rst-class-citizen    ␈↓ π∞␈↓not␈αone␈αthat␈αcan␈αbe␈αused␈αas␈αa␈α
variable).␈α And
␈↓ ↓N␈↓property␈α∂that␈α∂makes␈α∂LISP␈α∂so␈α∂pleasant␈α∂to␈α∂use        ␈↓ π∞␈↓bit␈α∩vectors␈α∩are␈α∩just␈α∩single-precision␈α⊃integers;
␈↓ ↓N␈↓yet␈α
simple␈αto␈α
implement␈αin␈α
the␈αevent␈α
that␈αyou       ␈↓ π∞␈↓indeed␈α∂only␈α∞the␈α∂presence␈α∂of␈α∞bit-manipulating
␈↓ ↓N␈↓are␈αwilling␈αto␈α
forego␈αe␈↓α␈↓β@␈↓α␈↓iciency␈αon␈αsome␈α
of␈αthe      ␈↓ π∞␈↓operations␈α∂permits␈α∂LISP␈α⊂to␈α∂claim␈α∂that␈α⊂it␈α∂has
␈↓ ↓N␈↓data␈α⊃types.␈α⊃ I␈α⊂believe␈α⊃that␈α⊃this␈α⊃concession␈α⊂to     ␈↓ π∞␈↓the␈α∞type␈α∞bit␈α∞vector.␈α∞ Though␈α∂this␈α∞typelessness
␈↓ ↓N␈↓e␈↓α␈↓β@␈↓α␈↓iciency,␈α⊃while␈α⊃it␈α⊃has␈α⊃many␈α⊃merits,␈α⊃detracts     ␈↓ π∞␈↓of␈α∂LISP␈α∂has␈α∂an␈α∂advantage␈α∂in␈α∂permitting␈α∂the
␈↓ ↓N␈↓considerably␈α(from␈α)PASCAL's␈α(otherwise           ␈↓ π∞␈↓user␈αto␈αsave␈αprogramming␈αtime␈αby␈αnot␈αhaving
␈↓ ↓N␈↓excellent␈α∀versatility.␈α∃ Nevertheless,␈α∀PASCAL   ␈↓ π∞␈↓to␈α⊃declare␈α⊃types,␈α⊃there␈α⊃remains␈α⊃the␈α∩fact␈α⊃that
␈↓ ↓N␈↓remains␈α1among␈α1the␈α2more␈α1attractive               ␈↓ π∞␈↓many␈αbugs␈α
are␈αdetectable␈αbecause␈α
they␈αviolate
␈↓ ↓N␈↓possibilities.                              ␈↓ π∞␈↓type␈α→constraints.␈α_ These␈α→violations␈α→will␈α_be
                                            ␈↓ π∞␈↓caught␈αby␈α
the␈αinterpreter␈α(if␈α
at␈αall)␈α
only␈αwhen
                                            ␈↓ π∞␈↓the␈α⊂o␈↓α␈↓β@␈↓α␈↓ending␈α⊂portion␈α⊂of␈α⊂the␈α⊂code␈α⊂is␈α⊂actually
                                            ␈↓ π∞␈↓run;␈α∞for␈α
this␈α∞reason␈α
some␈α∞LISP␈α∞users␈α
compile
                                            ␈↓ π∞␈↓their␈α≠newly␈α~written␈α≠code␈α~before␈α≠or␈α~even
␈↓ ↓N␈↓αLISP Brief␈↓ T12


␈↓ ↓N␈↓instead␈αof␈αdebugging␈αit␈αinterpretively␈αas␈αa␈α␈↓α␈↓βC␈↓α␈↓rst   ␈↓ π∞␈↓A␈αcontinual␈αsource␈αof␈α
petty␈αirritation␈αfor␈αme␈α
is
␈↓ ↓N␈↓debugging␈αstep␈αon␈αthe␈αground␈αthat␈αat␈αleast␈α
the      ␈↓ π∞␈↓the␈α∀compiler,␈α∀which␈α∀overlooks␈α∀many␈α∀simple
␈↓ ↓N␈↓compiler␈α_does␈α_a␈α_fair␈α_to␈α_moderate␈α→job␈α_of            ␈↓ π∞␈↓optimizations.␈α> However,␈α?my␈α>pique
␈↓ ↓N␈↓detecting␈α∞type␈α∞violations.␈α∞ This␈α∂philosophy␈α∞of   ␈↓ π∞␈↓notwithstanding,␈α∞the␈α∞compiler␈α∞is␈α∞probably␈α
the
␈↓ ↓N␈↓tight␈α∞control␈α
over␈α∞types␈α
is␈α∞at␈α
the␈α∞heart␈α∞of␈α
the      ␈↓ π∞␈↓best␈α⊂LISP␈α⊂compiler␈α⊂available␈α⊂anywhere␈α⊂as␈α⊂it
␈↓ ↓N␈↓design␈α⊂philosophy␈α⊂of␈α⊂Barbara␈α⊂Liskov's␈α∂CLU        ␈↓ π∞␈↓does␈α⊃a␈α⊂remarkably␈α⊃good␈α⊂job␈α⊃of␈α⊂optimization
␈↓ ↓N␈↓language␈α∞at␈α∞MIT␈α∞along␈α∞with␈α∂similar␈α∞research       ␈↓ π∞␈↓considering␈α
LISP's␈α
versatility.␈α
 No␈α
matter␈α
what
␈↓ ↓N␈↓languages␈α%at␈α&other␈α%campuses␈α&such␈α%as              ␈↓ π∞␈↓language␈α∞the␈α∞department␈α∞settles␈α∞on,␈α∞if␈α∞it␈α∞is␈α
as
␈↓ ↓N␈↓Carnegie-Mellon's ALPHARD language.         ␈↓ π∞␈↓powerful␈α
as␈α
LISP,␈α
people␈α
will␈α
be␈αcomplaining
                                            ␈↓ π∞␈↓about␈α∂overlooked␈α∂"obvious"␈α⊂optimizations␈α∂for
␈↓ ↓N␈↓Another␈α∂source␈α∂of␈α⊂troubles␈α∂with␈α∂LISP␈α⊂is␈α∂the        ␈↓ π∞␈↓quite a while, possibly for ever.
␈↓ ↓N␈↓classic␈α∂FUNARG␈α∂problem,␈α∞so␈α∂named␈α∂by␈α∞Joel
␈↓ ↓N␈↓Moses␈α~[4]␈α→in␈α~an␈α→early␈α~discussion␈α~of␈α→the            ␈↓ π∞␈↓One␈α∩can␈α∩come␈α∪up␈α∩with␈α∩a␈α∩variety␈α∪of␈α∩minor
␈↓ ↓N␈↓problem.␈α  Although␈α a␈α!completely␈α correct         ␈↓ π∞␈↓complaints␈αof␈αthis␈αilk,␈αbut␈αbeyond␈αthe␈α␈↓α␈↓βC␈↓α␈↓rst␈αtwo
␈↓ ↓N␈↓handling␈α
of␈α∞this␈α
problem␈α∞is␈α
not␈α∞at␈α
the␈α∞top␈α
of        ␈↓ π∞␈↓major␈α⊗complaints␈α⊗about␈α⊗LISP's␈α⊗typelessness
␈↓ ↓N␈↓all␈α
users'␈αlists␈α
of␈αdemands,␈α
it␈αis␈α
for␈α
some;␈αalso,   ␈↓ π∞␈↓(regarded␈α∪by␈α∩many␈α∪others␈α∩as␈α∪a␈α∪virtue)␈α∩and
␈↓ ↓N␈↓the␈αformal␈αdescription␈αof␈αLISP␈αis␈α
simpli␈↓α␈↓βC␈↓α␈↓ed␈αif     ␈↓ π∞␈↓lack␈α
of␈α
environment-manipulating␈α
capability,␈α
I
␈↓ ↓N␈↓one␈αassumes␈αthat␈αthe␈αproblem,␈α
which␈αinvolves      ␈↓ π∞␈↓personally␈α"am␈α!pretty␈α"satis␈↓α␈↓βC␈↓α␈↓ed␈α"with␈α!the
␈↓ ↓N␈↓being␈α&able␈α&to␈α&pass␈α&around␈α%program-               ␈↓ π∞␈↓language.
␈↓ ↓N␈↓environment␈α
pairs␈α
just␈α
like␈α
any␈α
other␈α∞data,␈α
is
␈↓ ↓N␈↓properly␈α∩taken␈α∪care␈α∩of.␈α∪ As␈α∩things␈α∪stand␈α∩at
␈↓ ↓N␈↓present,␈α∪the␈α∪partial␈α∪solution␈α∪implemented␈α∩in     ␈↓ π∞␈↓C.  DEPARTMENTAL REQUIREMENTS.
␈↓ ↓N␈↓MACLISP␈α∀is␈α∪better␈α∀described␈α∪operationally,
␈↓ ↓N␈↓leading␈α
to␈α
a␈α
more␈α
clumsy␈α
description␈α
of␈αLISP       ␈↓ π∞␈↓Though␈αthe␈αdepartment␈αhas␈αasked␈αfor␈α
a␈αgood
␈↓ ↓N␈↓than␈α⊂is␈α⊂possible␈α⊂otherwise.␈α⊃ Several␈α⊂plausible   ␈↓ π∞␈↓educational␈α
language,␈α
there␈α
is␈α
no␈α
harm␈α
(if␈α
we
␈↓ ↓N␈↓solutions␈α (by␈α Richard␈α Greenblatt,␈α∨Henry         ␈↓ π∞␈↓are␈α_considering␈α_LISP)␈α_in␈α_asking␈α_that␈α_the
␈↓ ↓N␈↓Baker,␈α
Guy␈α
Steele␈α
and␈α
Gerald␈α
Sussman)␈αare␈α
in       ␈↓ π∞␈↓research␈α↔needs␈α_of␈α↔the␈α↔department␈α_also␈α↔be
␈↓ ↓N␈↓the␈α⊂air,␈α⊂and␈α⊂one␈α⊂may␈α⊂soon␈α⊂␈↓α␈↓βC␈↓α␈↓nd␈α⊂its␈α⊂way␈α∂into           ␈↓ π∞␈↓considered.␈α⊂ Here␈α⊂are␈α⊂a␈α⊂number␈α⊃of␈α⊂headings
␈↓ ↓N␈↓MACLISP.                                    ␈↓ π∞␈↓(suggested␈α∃to␈α∃me␈α∃by␈α∃Ronald␈α∃Rivest)␈α∃under
                                            ␈↓ π∞␈↓which one may ask about the utility of LISP.
␈↓ ↓N␈↓A␈αmuch␈αless␈αserious␈αcomplaint␈αis␈αthat␈αthe␈αuser
␈↓ ↓N␈↓may␈α∞not␈α
specify␈α∞a␈α
lower␈α∞bound␈α
for␈α∞any␈α
array         ␈↓ π∞␈↓1.␈αDesktop␈αcalculators.␈α As␈αpointed␈α
out␈αbefore,
␈↓ ↓N␈↓dimension␈α∩other␈α∩than␈α⊃0.␈α∩ To␈α∩an␈α∩extent␈α⊃this         ␈↓ π∞␈↓one␈α∪need␈α∪merely␈α∪type␈α∪1+2*3␈α∪followed␈α∪by␈α∪a
␈↓ ↓N␈↓objection␈α%can␈α%be␈α%overcome␈α&using␈α%the              ␈↓ π∞␈↓termination␈α⊗character␈α⊗to␈α∃get␈α⊗the␈α⊗answer␈α∃7.
␈↓ ↓N␈↓notational␈α∞␈↓α␈↓βD␈↓α␈↓exibility␈α∞discussed␈α∞in␈α∞section␈α∞6␈α
by   ␈↓ π∞␈↓Although␈α∀my␈α∪secretary␈α∀cannot␈α∀program␈α∪she
␈↓ ↓N␈↓permitting␈α⊂a(i)␈α⊂to␈α⊃denote␈α⊂(A␈α⊂(PLUS␈α⊂I␈α⊃7))␈α⊂or         ␈↓ π∞␈↓has␈α∀used␈α∀LISP␈α∪regularly␈α∀for␈α∀two␈α∀years␈α∪for
␈↓ ↓N␈↓whatever.␈α Another␈αcomplaint␈αis␈αthat␈αwith␈αthe     ␈↓ π∞␈↓precisely␈α⊗this␈α⊗application,␈α⊗even␈α↔though␈α⊗the
␈↓ ↓N␈↓bit-vector␈α
data␈α
type,␈α
LISP␈α
itself␈α
only␈α
o␈↓α␈↓β@␈↓α␈↓ers␈α
36-   ␈↓ π∞␈↓bulk␈α↔of␈α↔her␈α⊗arithmetic␈α↔is␈α↔just␈α↔adding␈α⊗up
␈↓ ↓N␈↓bit␈αbit␈αvectors.␈α However,␈αLIBLSP␈α(the␈αpublic     ␈↓ π∞␈↓numbers.␈α∂ In␈α⊂fact␈α∂almost␈α∂any␈α⊂expression␈α∂that
␈↓ ↓N␈↓LISP␈α⊂software␈α⊂library␈α⊂on␈α⊂the␈α⊂ITS␈α∂machines)        ␈↓ π∞␈↓can␈α
be␈α∞typed␈α
on␈α∞an␈α
SR-51,␈α∞say,␈α
can␈α∞be␈α
typed
␈↓ ↓N␈↓o␈↓α␈↓β@␈↓α␈↓ers␈α
a␈α
package␈α
written␈α
by␈α
Henry␈α
Baker␈αthat        ␈↓ π∞␈↓almost␈α~verbatim␈α~to␈α~LISP.␈α~ Moreover,␈α~the
␈↓ ↓N␈↓confers␈α_e␈↓α␈↓β@␈↓α␈↓icient␈α→unlimited-length␈α_bit-vector   ␈↓ π∞␈↓comparatively␈α∀unlimited␈α∀storage␈α∀of␈α∃LISP␈α∀is
␈↓ ↓N␈↓processing␈α∞capability␈α∞on␈α∞LISP.␈α∂ This␈α∞package     ␈↓ π∞␈↓available␈α≡for␈α≥storing␈α≡intermediate␈α≥results.
␈↓ ↓N␈↓really␈α∂ought␈α∂to␈α⊂be␈α∂available␈α∂directly␈α⊂to␈α∂LISP      ␈↓ π∞␈↓Thus␈α∨a␈α≡LISP␈α∨terminal␈α≡consisting␈α∨of␈α≡a
␈↓ ↓N␈↓users.␈α~ In␈α~my␈α~LINGOL␈α~natural␈α→language            ␈↓ π∞␈↓calculator-sized␈α∨keyboard␈α≡and␈α∨a␈α≡15-digit
␈↓ ↓N␈↓system,␈α∂which␈α∂does␈α∂a␈α∂considerable␈α∂amount␈α∞of       ␈↓ π∞␈↓display␈α≡would␈α≡already␈α∨provide␈α≡enormous
␈↓ ↓N␈↓set-oriented␈α8processing␈α8involving␈α7set          ␈↓ π∞␈↓power.␈α Going␈αto␈αa␈α30-character␈αalphanumeric
␈↓ ↓N␈↓intersection␈α≥and␈α≥union,␈α≥bit␈α≥vectors␈α≥have         ␈↓ π∞␈↓display␈α∩would␈α⊃increase␈α∩the␈α⊃utility␈α∩of␈α∩such␈α⊃a
␈↓ ↓N␈↓supplied␈α∃a␈α∀very␈α∃e␈↓α␈↓β@␈↓α␈↓icient␈α∃implementation␈α∀of       ␈↓ π∞␈↓terminal␈αconsiderably.␈αSuch␈αterminals␈αcould␈α
be
␈↓ ↓N␈↓sets.
␈↓ ↓N␈↓αLISP Brief␈↓ T13


␈↓ ↓N␈↓so␈αcheap␈αthat␈αeach␈αo␈↓α␈↓β@␈↓α␈↓ice␈αin␈αthe␈αbuilding␈α
could      ␈↓ π∞␈↓4.␈α∩ Publication␈α⊃Language.␈α∩ This␈α⊃is␈α∩one␈α⊃area
␈↓ ↓N␈↓have␈α∨two␈α or␈α∨more␈α∨if␈α necessary.␈α∨ With              ␈↓ π∞␈↓where␈α≠the␈α≠case␈α≠for␈α≠LISP␈α≠is␈α≠not␈α~strong.
␈↓ ↓N␈↓reasonable␈α∀system␈α∀design,␈α∀the␈α∀formalities␈α∀of     ␈↓ π∞␈↓Although␈αLISP's␈αstandard␈αnotation␈αis␈αpopular
␈↓ ↓N␈↓logging␈α∩such␈α∩terminals␈α∩on␈α∩and␈α∩o␈↓α␈↓β@␈↓α␈↓␈α∩could␈α⊃be          ␈↓ π∞␈↓with␈α∞many␈α∂LISP␈α∞users,␈α∂it␈α∞does␈α∂take␈α∞su␈↓α␈↓β@␈↓α␈↓icient
␈↓ ↓N␈↓dispensed␈α!with.␈α! Thus␈α!LISP␈α!would␈α!be              ␈↓ π∞␈↓getting␈α⊂used␈α⊂to␈α⊂that␈α∂it␈α⊂is␈α⊂not␈α⊂an␈α∂appropriate
␈↓ ↓N␈↓available␈α≥as␈α≥a␈α≥powerful␈α≥replacement␈α≥for          ␈↓ π∞␈↓publication␈α
language␈α
except␈α
in␈α
AI␈αcircles,␈α
since
␈↓ ↓N␈↓programmable␈α
calculators,␈α
yet␈α
lacking␈α
none␈α
of    ␈↓ π∞␈↓outside␈α∂of␈α∂AI␈α∂the␈α∂world␈α∂is␈α⊂very␈α∂algebraically
␈↓ ↓N␈↓their␈α∪convenience.␈α∀ The␈α∪possibility␈α∀exists␈α∪of    ␈↓ π∞␈↓oriented.␈α⊃ The␈α∩fact␈α⊃that␈α⊃an␈α∩algebraic␈α⊃dialect
␈↓ ↓N␈↓making␈α
such␈α∞terminals␈α
completely␈α∞portable,␈α
at    ␈↓ π∞␈↓for␈α∀LISP␈α∪only␈α∀helps␈α∀if␈α∪that␈α∀dialect␈α∀is␈α∪well
␈↓ ↓N␈↓least␈α⊂within␈α⊂the␈α⊂building,␈α⊂relying␈α⊂on␈α⊂a␈α∂radio      ␈↓ π∞␈↓known,␈αor␈αat␈αleast␈αunderstandable␈αwithout␈αlots
␈↓ ↓N␈↓link for contact with the department's system.␈↓ π∞␈↓of␈α∩explanation,␈α∪which␈α∩is␈α∪not␈α∩at␈α∪present␈α∩the
                                            ␈↓ π∞␈↓case␈α~for␈α≠any␈α~of␈α≠the␈α~MLISP,␈α≠CGOL␈α~or
␈↓ ↓N␈↓2.␈α≤ Number-crunching.␈α≠ We␈α≤have␈α≠already          ␈↓ π∞␈↓MACSYMA␈α≤dialects.␈α≤One␈α≤solution␈α≤is␈α≤to
␈↓ ↓N␈↓referred␈α∂to␈α∂Bers'␈α∂Plasma␈α∂Dynamics␈α⊂group,␈α∂in       ␈↓ π∞␈↓translate␈α⊗the␈α⊗algebraic␈α⊗dialect␈α⊗into␈α⊗a␈α∃well-
␈↓ ↓N␈↓the␈α∀section␈α∀on␈α∀e␈↓α␈↓β@␈↓α␈↓iciency.␈α∀ This␈α∃supplies␈α∀an       ␈↓ π∞␈↓known␈α∞language;␈α∞this␈α
may␈α∞only␈α∞be␈α∞possible␈α
if
␈↓ ↓N␈↓example␈α∃of␈α∃where␈α⊗LISP␈α∃is␈α∃already␈α⊗in␈α∃use            ␈↓ π∞␈↓some␈α
restraint␈α∞is␈α
used␈α∞in␈α
taking␈α∞advantage␈α
of
␈↓ ↓N␈↓within␈α,the␈α,department␈α,for␈α,"number-              ␈↓ π∞␈↓LISP's␈αversatility.␈α Another␈αpossibility␈αis␈αto␈αgo
␈↓ ↓N␈↓crunching" on a large scale.                ␈↓ π∞␈↓ahead␈α∩and␈α∩use␈α∩an␈α∩algebraic␈α∩dialect␈α∩of␈α⊃full-
                                            ␈↓ π∞␈↓blown␈α0LISP␈α/on␈α0the␈α/chauvinistically
␈↓ ↓N␈↓3.␈α≠ Classroom␈α≠language.␈α≠ Not␈α~surprisingly,      ␈↓ π∞␈↓evangelical␈α∞ground␈α∞that␈α∞the␈α∞rest␈α∞of␈α∞the␈α∞world
␈↓ ↓N␈↓LISP␈α∪is␈α∩the␈α∪classroom␈α∩language␈α∪for␈α∩Patrick        ␈↓ π∞␈↓ought␈α≥to␈α≡learn␈α≥such␈α≥a␈α≡lovely␈α≥language,
␈↓ ↓N␈↓Winston's␈α-AI␈α-course.␈α. Perhaps␈α-more              ␈↓ π∞␈↓especially␈α∃when␈α∃they␈α∃aren't␈α∃being␈α∃asked␈α∃to
␈↓ ↓N␈↓surprisingly␈α
is␈α
that␈α
it␈α
is␈α
also␈α
the␈α∞language␈α
for    ␈↓ π∞␈↓su␈↓α␈↓β@␈↓α␈↓er␈α⊂the␈α⊂fully␈α⊂parenthesized␈α⊂notation.␈α∂ This
␈↓ ↓N␈↓my␈α∀undergraduate␈α∀algorithms␈α∃course,␈α∀which       ␈↓ π∞␈↓issue␈α
should␈αbe␈α
brought␈α
up␈αin␈α
any␈α
defense␈αof
␈↓ ↓N␈↓teaches␈α_the␈α_sort␈α_of␈α_material␈α_one␈α_␈↓α␈↓βC␈↓α␈↓nds␈α_in           ␈↓ π∞␈↓PASCAL,␈α↔where␈α↔it␈α⊗is␈α↔more␈α↔reasonable␈α⊗at
␈↓ ↓N␈↓Donald␈α∂Knuth's␈α⊂volumes␈α∂on␈α⊂algorithms.␈α∂ We        ␈↓ π∞␈↓present␈α∂to␈α∂assume␈α∂that␈α∂the␈α∂reader␈α⊂can␈α∂follow
␈↓ ↓N␈↓deal␈α∩with␈α∩graph␈α∩and␈α∩matrix␈α∪algorithms,␈α∩bit        ␈↓ π∞␈↓PASCAL code.
␈↓ ↓N␈↓vector␈α
algorithms,␈α∞integer␈α
and␈α∞real␈α
arithmetic,
␈↓ ↓N␈↓storage␈αmanagement,␈αinformation␈αorganization   ␈↓ π∞␈↓In␈α∀summary,␈α∀I␈α∪would␈α∀say␈α∀very␈α∀simply␈α∪that
␈↓ ↓N␈↓and␈α→retrieval,␈α_and␈α→sorting.␈α→ The␈α_language        ␈↓ π∞␈↓LISP␈α⊃would␈α⊂make␈α⊃an␈α⊃excellent␈α⊂departmental
␈↓ ↓N␈↓(which␈α I␈α call␈α "The␈α!6.046␈α programming             ␈↓ π∞␈↓language.␈α⊂ All␈α⊃things␈α⊂considered,␈α⊂it␈α⊃has␈α⊂little
␈↓ ↓N␈↓language"␈α∂so␈α⊂that␈α∂any␈α⊂opponents␈α∂of␈α⊂LISP␈α∂in         ␈↓ π∞␈↓serious␈α
competition␈α∞from␈α
any␈α∞language␈α
except
␈↓ ↓N␈↓the␈α_class␈α_won't␈α→take␈α_o␈↓α␈↓β@␈↓α␈↓ence␈α_-␈α→they␈α_don't           ␈↓ π∞␈↓PASCAL,␈α≥and␈α≥even␈α≥that␈α≡competition␈α≥is
␈↓ ↓N␈↓recognize␈α↔LISP␈α↔in␈α↔its␈α↔algebraic␈α↔dialect)␈α↔is       ␈↓ π∞␈↓minimal.␈α∩ At␈α∩this␈α∩point␈α∩it␈α∩is␈α∩appropriate␈α∩to
␈↓ ↓N␈↓spelled␈α
out␈α
in␈α
a␈α
class␈α
handout␈α
and␈αstudents␈α
are     ␈↓ π∞␈↓include␈α∂the␈α∞␈↓↓ad␈α∂hominem␈↓␈α∞argument␈α∂that␈α∞LISP,
␈↓ ↓N␈↓required␈αto␈αstick␈αto␈αit.␈α This␈αgives␈αthe␈αstudents   ␈↓ π∞␈↓an␈α↔MIT␈α_product,␈α↔has␈α↔had␈α_a␈α↔considerable
␈↓ ↓N␈↓a␈α≤simple-to-learn␈α≠yet␈α≤versatile␈α≤and␈α≠well-        ␈↓ π∞␈↓impact␈αon␈αthe␈αacademic␈αcomputing␈αcommunity
␈↓ ↓N␈↓de␈↓α␈↓βC␈↓α␈↓ned␈α⊃language␈α⊂that␈α⊃simpli␈↓α␈↓βC␈↓α␈↓es␈α⊃our␈α⊂grading.      ␈↓ π∞␈↓over␈α⊂the␈α⊃past␈α⊂decade␈α⊂and␈α⊃a␈α⊂half,␈α⊃and␈α⊂along
␈↓ ↓N␈↓The␈αversatility␈αof␈αLISP␈αsimpli␈↓α␈↓βC␈↓α␈↓es␈αmany␈αof␈αthe      ␈↓ π∞␈↓with␈αmagnetic␈αcore␈αstorage,␈αCTSS,␈αMULTICS
␈↓ ↓N␈↓algorithms␈α⊗I␈α↔teach,␈α⊗and␈α↔at␈α⊗the␈α↔same␈α⊗time           ␈↓ π∞␈↓and␈α∃MACSYMA␈α⊗has␈α∃been␈α⊗responsible␈α∃for
␈↓ ↓N␈↓makes␈α∪it␈α∩possible␈α∪for␈α∪us␈α∩to␈α∪run␈α∪a␈α∩student's         ␈↓ π∞␈↓making␈α≡MIT␈α≥close␈α≡to␈α≥the␈α≡world's␈α≥most
␈↓ ↓N␈↓algorithm␈α_on␈α↔the␈α_computer␈α↔if␈α_neither␈α↔the          ␈↓ π∞␈↓in␈↓↓␈↓βD␈↓↓␈↓uential source of Computer Science ideas.
␈↓ ↓N␈↓T.A.'s␈α≠nor␈α≠I␈α~can␈α≠understand␈α≠what␈α≠it␈α~is
␈↓ ↓N␈↓supposed␈α$to␈α%be␈α$doing,␈α$a␈α%feature␈α$we
␈↓ ↓N␈↓occasionally␈α&take␈α&advantage␈α&of.␈α& It␈α%is           ␈↓ π∞␈↓α␈↓ λbBibliography.
␈↓ ↓N␈↓regrettable␈α_that␈α_we␈α_cannot␈α→o␈↓α␈↓β@␈↓α␈↓er␈α_unlimited
␈↓ ↓N␈↓access␈αto␈α
LISP␈αfor␈α
the␈αstudents,␈α
a␈αfact␈αwe␈α
have      ␈↓ π∞␈↓[1]␈α Fateman,␈α∨Richard␈α J.␈α∨"Reply␈α to␈α∨an
␈↓ ↓N␈↓to␈α
keep␈αperpetually␈α
in␈αmind␈α
when␈α
setting␈αand       ␈↓ π∞␈↓␈↓ π↑Editorial."␈α∩SIGSAM␈α∩Bulletin␈α∩25,␈α⊃9-11.
␈↓ ↓N␈↓grading␈α?␈αεproblems␈α?␈αεrequiring␈α?␈αεsome                ␈↓ π∞␈↓␈↓ π↑(March 1973).
␈↓ ↓N␈↓programming.
␈↓ ↓N␈↓αLISP Brief␈↓ Q14


␈↓ ↓N␈↓[2]␈α⊂Hewitt,␈α⊂C.␈α⊂E.,␈α∂P.␈α⊂Bishop,␈α⊂and␈α⊂R.␈α∂Steiger.
␈↓ ↓N␈↓␈↓ α≡"A␈α.Universal␈α.Modular␈α-ACTOR
␈↓ ↓N␈↓␈↓ α≡Formalism␈α~for␈α≠Arti␈↓↓␈↓βC␈↓↓␈↓cial␈α~Intelligence,"
␈↓ ↓N␈↓␈↓ α≡Proc. IJCAI 3, p. 235. 1973.

␈↓ ↓N␈↓[3]␈α,McKay,␈α,John␈α,and␈α-E.␈α,Regener.
␈↓ ↓N␈↓␈↓ α≡"Transitivity␈α%Sets."␈α%Algorithm␈α%482,
␈↓ ↓N␈↓␈↓ α≡CACM 17, 8, 470.  (August 1974).

␈↓ ↓N␈↓[4]␈α-Moses,␈α-Joel.␈α-"The␈α.Function␈α-of
␈↓ ↓N␈↓␈↓ α≡FUNCTION␈α⊂in␈α∂LISP."␈α⊂AI␈α⊂Memo␈α∂199,
␈↓ ↓N␈↓␈↓ α≡MIT AI Lab (Cambridge, June 1970).

␈↓ ↓N␈↓[5]␈α(Popplestone,␈α(R.␈α(J.␈α( "The␈α(Design
␈↓ ↓N␈↓␈↓ α≡Philosophy␈α,of␈α,POP-2."␈α,Machine
␈↓ ↓N␈↓␈↓ α≡Intelligence␈α⊂3␈α⊂(ed.␈α⊂D.␈α⊂Michie),␈α∂393-402,
␈↓ ↓N␈↓␈↓ α≡Edinburgh U. Press, 1968.

␈↓ ↓N␈↓[6]␈α≥Pratt,␈α≥V.␈α≤R.␈α≥ "Top␈α≥Down␈α≤Operator
␈↓ ↓N␈↓␈↓ α≡Precedence."␈α?␈α4Proc.␈α?␈α3ACM
␈↓ ↓N␈↓␈↓ α≡SIGACT/SIGPLAN␈α?␈α∞Conf.␈α?␈α∞on
␈↓ ↓N␈↓␈↓ α≡Principles␈α∪of␈α∀Programming␈α∪Languages
␈↓ ↓N␈↓␈↓ α≡(POPL 1), Boston.  (October 1973).

␈↓ ↓N␈↓[7]␈α.␈↓↓␈↓βE␈↓↓␈↓␈↓↓␈↓βE␈↓↓␈↓␈↓↓␈↓βE␈↓↓␈↓␈↓↓␈↓βE␈↓↓␈↓.␈α. "A␈α.Linguistics␈α-Oriented
␈↓ ↓N␈↓␈↓ α≡Programming␈α Language."␈α!Proc.␈α 3rd
␈↓ ↓N␈↓␈↓ α≡International␈α∀Joint␈α∪Conference␈α∀on␈α∪AI,
␈↓ ↓N␈↓␈↓ α≡Stanford, 1973.

␈↓ ↓N␈↓[8]␈α␈↓↓␈↓βE␈↓↓␈↓␈↓↓␈↓βE␈↓↓␈↓␈↓↓␈↓βE␈↓↓␈↓␈↓↓␈↓βE␈↓↓␈↓.␈α "CGOL␈α-␈αan␈αAlternative␈αExternal
␈↓ ↓N␈↓␈↓ α≡Representation␈α∩For␈α∩LISP␈α∩Users."␈α∩MIT
␈↓ ↓N␈↓␈↓ α≡AI Lab Working Paper 89.  1976.

␈↓ ↓N␈↓[9]␈α↔Steele,␈α_Guy␈α↔Lewis␈α_Jr.␈α↔"Multiprocessing
␈↓ ↓N␈↓␈↓ α≡Compactifying␈α*Garbage␈α)Collection."
␈↓ ↓N␈↓␈↓ α≡Comm.␈α1ACM␈α118,␈α19,␈α0495-508.
␈↓ ↓N␈↓␈↓ α≡(September 1975).